/*
 * Copyright (c) 2011.
 * This file is part of "Freud".
 *
 * Freud is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Freud is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Freud.  If not, see <http://www.gnu.org/licenses/>.
 * @author Amir Langer  langera_at_gmail_dot_com
 */

// $ANTLR 3.2 Sep 23, 2009 12:02:23 /home/langera/dev/freud/trunk/src/grammar/Java.g 2010-02-19 14:59:01

package org.langera.freud.optional.javasource.parser;


import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.BitSet;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.IntStream;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.Parser;
import org.antlr.runtime.ParserRuleReturnScope;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;
import org.antlr.runtime.Token;
import org.antlr.runtime.TokenStream;
import org.antlr.runtime.tree.CommonTree;
import org.antlr.runtime.tree.CommonTreeAdaptor;
import org.antlr.runtime.tree.RewriteEarlyExitException;
import org.antlr.runtime.tree.RewriteRuleSubtreeStream;
import org.antlr.runtime.tree.RewriteRuleTokenStream;
import org.antlr.runtime.tree.TreeAdaptor;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class JavaParser extends Parser
{
    public static final String[] tokenNames = new String[]{
            "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AND", "AND_ASSIGN", "ASSIGN", "AT", "BIT_SHIFT_RIGHT", "BIT_SHIFT_RIGHT_ASSIGN", "COLON", "COMMA", "DEC", "DIV", "DIV_ASSIGN", "DOT", "DOTSTAR", "ELLIPSIS", "EQUAL", "GREATER_OR_EQUAL", "GREATER_THAN", "INC", "LBRACK", "LCURLY", "LESS_OR_EQUAL", "LESS_THAN", "LOGICAL_AND", "LOGICAL_NOT", "LOGICAL_OR", "LPAREN", "MINUS", "MINUS_ASSIGN", "MOD", "MOD_ASSIGN", "NOT", "NOT_EQUAL", "OR", "OR_ASSIGN", "PLUS", "PLUS_ASSIGN", "QUESTION", "RBRACK", "RCURLY", "RPAREN", "SEMI", "SHIFT_LEFT", "SHIFT_LEFT_ASSIGN", "SHIFT_RIGHT", "SHIFT_RIGHT_ASSIGN", "STAR", "STAR_ASSIGN", "XOR", "XOR_ASSIGN", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS", "FALSE", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "IMPLEMENTS", "INSTANCEOF", "INTERFACE", "IMPORT", "INT", "LONG", "NATIVE", "NEW", "NULL", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", "TRUE", "TRY", "VOID", "VOLATILE", "WHILE", "ANNOTATION_INIT_ARRAY_ELEMENT", "ANNOTATION_INIT_BLOCK", "ANNOTATION_INIT_DEFAULT_KEY", "ANNOTATION_INIT_KEY_LIST", "ANNOTATION_LIST", "ANNOTATION_METHOD_DECL", "ANNOTATION_SCOPE", "ANNOTATION_TOP_LEVEL_SCOPE", "ARGUMENT_LIST", "ARRAY_DECLARATOR", "ARRAY_DECLARATOR_LIST", "ARRAY_ELEMENT_ACCESS", "ARRAY_INITIALIZER", "BLOCK_SCOPE", "CAST_EXPR", "CATCH_CLAUSE_LIST", "CLASS_CONSTRUCTOR_CALL", "CLASS_INSTANCE_INITIALIZER", "CLASS_STATIC_INITIALIZER", "CLASS_TOP_LEVEL_SCOPE", "CONSTRUCTOR_DECL", "ENUM_TOP_LEVEL_SCOPE", "EXPR", "EXTENDS_BOUND_LIST", "EXTENDS_CLAUSE", "FOR_CONDITION", "FOR_EACH", "FOR_INIT", "FOR_UPDATE", "FORMAL_PARAM_LIST", "FORMAL_PARAM_STD_DECL", "FORMAL_PARAM_VARARG_DECL", "FUNCTION_METHOD_DECL", "GENERIC_TYPE_ARG_LIST", "GENERIC_TYPE_PARAM_LIST", "INTERFACE_TOP_LEVEL_SCOPE", "IMPLEMENTS_CLAUSE", "LABELED_STATEMENT", "LOCAL_MODIFIER_LIST", "JAVA_SOURCE", "METHOD_CALL", "MODIFIER_LIST", "PARENTESIZED_EXPR", "POST_DEC", "POST_INC", "PRE_DEC", "PRE_INC", "QUALIFIED_TYPE_IDENT", "STATIC_ARRAY_CREATOR", "SUPER_CONSTRUCTOR_CALL", "SWITCH_BLOCK_LABEL_LIST", "THIS_CONSTRUCTOR_CALL", "THROWS_CLAUSE", "TYPE", "UNARY_MINUS", "UNARY_PLUS", "VAR_DECLARATION", "VAR_DECLARATOR", "VAR_DECLARATOR_LIST", "VOID_METHOD_DECL", "IDENT", "HEX_LITERAL", "OCTAL_LITERAL", "DECIMAL_LITERAL", "FLOATING_POINT_LITERAL", "CHARACTER_LITERAL", "STRING_LITERAL", "HEX_DIGIT", "INTEGER_TYPE_SUFFIX", "EXPONENT", "FLOAT_TYPE_SUFFIX", "ESCAPE_SEQUENCE", "UNICODE_ESCAPE", "OCTAL_ESCAPE", "JAVA_ID_START", "JAVA_ID_PART", "WS", "BLOCK_COMMENT", "JAVADOC_COMMENT", "LINE_COMMENT"
    };
    public static final int PACKAGE = 84;
    public static final int EXPONENT = 173;
    public static final int STAR = 49;
    public static final int WHILE = 103;
    public static final int MOD = 32;
    public static final int MOD_ASSIGN = 33;
    public static final int CASE = 58;
    public static final int CHAR = 60;
    public static final int NEW = 82;
    public static final int DO = 64;
    public static final int GENERIC_TYPE_PARAM_LIST = 138;
    public static final int CLASS_INSTANCE_INITIALIZER = 121;
    public static final int ARRAY_ELEMENT_ACCESS = 115;
    public static final int FOR_CONDITION = 129;
    public static final int NOT = 34;
    public static final int VAR_DECLARATION = 160;
    public static final int ANNOTATION_METHOD_DECL = 109;
    public static final int EOF = -1;
    public static final int DIV_ASSIGN = 14;
    public static final int LOGICAL_AND = 26;
    public static final int BREAK = 56;
    public static final int UNARY_PLUS = 159;
    public static final int BIT_SHIFT_RIGHT_ASSIGN = 9;
    public static final int TYPE = 157;
    public static final int RPAREN = 43;
    public static final int INC = 21;
    public static final int FINAL = 70;
    public static final int IMPORT = 78;
    public static final int STRING_LITERAL = 170;
    public static final int FOR_UPDATE = 132;
    public static final int FLOATING_POINT_LITERAL = 168;
    public static final int CAST_EXPR = 118;
    public static final int NOT_EQUAL = 35;
    public static final int VOID_METHOD_DECL = 163;
    public static final int THIS = 95;
    public static final int RETURN = 88;
    public static final int BLOCK_COMMENT = 181;
    public static final int DOUBLE = 65;
    public static final int ENUM_TOP_LEVEL_SCOPE = 125;
    public static final int VOID = 101;
    public static final int SUPER = 92;
    public static final int ANNOTATION_INIT_KEY_LIST = 107;
    public static final int JAVA_ID_START = 178;
    public static final int FLOAT_TYPE_SUFFIX = 174;
    public static final int PRE_DEC = 149;
    public static final int RBRACK = 41;
    public static final int IMPLEMENTS_CLAUSE = 140;
    public static final int SWITCH_BLOCK_LABEL_LIST = 154;
    public static final int LINE_COMMENT = 183;
    public static final int PRIVATE = 85;
    public static final int STATIC = 90;
    public static final int BLOCK_SCOPE = 117;
    public static final int ANNOTATION_INIT_DEFAULT_KEY = 106;
    public static final int SWITCH = 93;
    public static final int NULL = 83;
    public static final int VAR_DECLARATOR = 161;
    public static final int MINUS_ASSIGN = 31;
    public static final int ELSE = 66;
    public static final int STRICTFP = 91;
    public static final int CHARACTER_LITERAL = 169;
    public static final int PRE_INC = 150;
    public static final int ANNOTATION_LIST = 108;
    public static final int ELLIPSIS = 17;
    public static final int NATIVE = 81;
    public static final int OCTAL_ESCAPE = 177;
    public static final int UNARY_MINUS = 158;
    public static final int THROWS = 97;
    public static final int LCURLY = 23;
    public static final int INT = 79;
    public static final int FORMAL_PARAM_VARARG_DECL = 135;
    public static final int METHOD_CALL = 144;
    public static final int ASSERT = 54;
    public static final int TRY = 100;
    public static final int INTERFACE_TOP_LEVEL_SCOPE = 139;
    public static final int SHIFT_LEFT = 45;
    public static final int WS = 180;
    public static final int SHIFT_RIGHT = 47;
    public static final int FORMAL_PARAM_STD_DECL = 134;
    public static final int LOCAL_MODIFIER_LIST = 142;
    public static final int OR = 36;
    public static final int LESS_THAN = 25;
    public static final int SHIFT_RIGHT_ASSIGN = 48;
    public static final int EXTENDS_BOUND_LIST = 127;
    public static final int JAVA_SOURCE = 143;
    public static final int CATCH = 59;
    public static final int FALSE = 69;
    public static final int INTEGER_TYPE_SUFFIX = 172;
    public static final int DECIMAL_LITERAL = 167;
    public static final int THROW = 96;
    public static final int FOR_INIT = 131;
    public static final int DEC = 12;
    public static final int PROTECTED = 86;
    public static final int CLASS = 61;
    public static final int LBRACK = 22;
    public static final int BIT_SHIFT_RIGHT = 8;
    public static final int THROWS_CLAUSE = 156;
    public static final int GREATER_OR_EQUAL = 19;
    public static final int FOR = 73;
    public static final int THIS_CONSTRUCTOR_CALL = 155;
    public static final int LOGICAL_NOT = 27;
    public static final int JAVADOC_COMMENT = 182;
    public static final int FLOAT = 72;
    public static final int ABSTRACT = 53;
    public static final int AND = 4;
    public static final int POST_DEC = 147;
    public static final int AND_ASSIGN = 5;
    public static final int STATIC_ARRAY_CREATOR = 152;
    public static final int MODIFIER_LIST = 145;
    public static final int ANNOTATION_SCOPE = 110;
    public static final int LPAREN = 29;
    public static final int IF = 74;
    public static final int AT = 7;
    public static final int ESCAPE_SEQUENCE = 175;
    public static final int CONSTRUCTOR_DECL = 124;
    public static final int LABELED_STATEMENT = 141;
    public static final int UNICODE_ESCAPE = 176;
    public static final int EXPR = 126;
    public static final int SYNCHRONIZED = 94;
    public static final int BOOLEAN = 55;
    public static final int CLASS_TOP_LEVEL_SCOPE = 123;
    public static final int IMPLEMENTS = 75;
    public static final int CONTINUE = 62;
    public static final int COMMA = 11;
    public static final int TRANSIENT = 98;
    public static final int EQUAL = 18;
    public static final int XOR_ASSIGN = 52;
    public static final int LOGICAL_OR = 28;
    public static final int IDENT = 164;
    public static final int QUALIFIED_TYPE_IDENT = 151;
    public static final int ARGUMENT_LIST = 112;
    public static final int PLUS = 38;
    public static final int HEX_LITERAL = 165;
    public static final int ANNOTATION_INIT_BLOCK = 105;
    public static final int DOT = 15;
    public static final int SHIFT_LEFT_ASSIGN = 46;
    public static final int FORMAL_PARAM_LIST = 133;
    public static final int GENERIC_TYPE_ARG_LIST = 137;
    public static final int ANNOTATION_TOP_LEVEL_SCOPE = 111;
    public static final int DOTSTAR = 16;
    public static final int BYTE = 57;
    public static final int XOR = 51;
    public static final int JAVA_ID_PART = 179;
    public static final int GREATER_THAN = 20;
    public static final int VOLATILE = 102;
    public static final int PARENTESIZED_EXPR = 146;
    public static final int CLASS_STATIC_INITIALIZER = 122;
    public static final int ARRAY_DECLARATOR_LIST = 114;
    public static final int LESS_OR_EQUAL = 24;
    public static final int DEFAULT = 63;
    public static final int OCTAL_LITERAL = 166;
    public static final int HEX_DIGIT = 171;
    public static final int SHORT = 89;
    public static final int INSTANCEOF = 76;
    public static final int MINUS = 30;
    public static final int EXTENDS_CLAUSE = 128;
    public static final int TRUE = 99;
    public static final int SEMI = 44;
    public static final int STAR_ASSIGN = 50;
    public static final int VAR_DECLARATOR_LIST = 162;
    public static final int ARRAY_DECLARATOR = 113;
    public static final int COLON = 10;
    public static final int OR_ASSIGN = 37;
    public static final int ENUM = 67;
    public static final int QUESTION = 40;
    public static final int FINALLY = 71;
    public static final int RCURLY = 42;
    public static final int PLUS_ASSIGN = 39;
    public static final int ASSIGN = 6;
    public static final int ANNOTATION_INIT_ARRAY_ELEMENT = 104;
    public static final int FUNCTION_METHOD_DECL = 136;
    public static final int INTERFACE = 77;
    public static final int POST_INC = 148;
    public static final int DIV = 13;
    public static final int CLASS_CONSTRUCTOR_CALL = 120;
    public static final int LONG = 80;
    public static final int FOR_EACH = 130;
    public static final int EXTENDS = 68;
    public static final int PUBLIC = 87;
    public static final int ARRAY_INITIALIZER = 116;
    public static final int CATCH_CLAUSE_LIST = 119;
    public static final int SUPER_CONSTRUCTOR_CALL = 153;

    // delegates
    // delegators


    public JavaParser(TokenStream input)
    {
        this(input, new RecognizerSharedState());
    }

    public JavaParser(TokenStream input, RecognizerSharedState state)
    {
        super(input, state);
        this.state.ruleMemo = new HashMap[357 + 1];


    }

    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor)
    {
        this.adaptor = adaptor;
    }

    public TreeAdaptor getTreeAdaptor()
    {
        return adaptor;
    }

    public String[] getTokenNames()
    {
        return JavaParser.tokenNames;
    }

    public String getGrammarFileName()
    {
        return "/home/langera/dev/freud/trunk/src/grammar/Java.g";
    }


    private boolean mMessageCollectionEnabled = false;
    private List<String> mMessages;

    /**
     * Switches error message collection on or of.
     * <p/>
     * The standard destination for parser error messages is <code>
     * System.err</code>. However, if <code>true</code> gets passed to this methoddecl
     * this default behaviour will be switched off and all error messages will be
     * collected instead of writing them to an output stream.
     * <p/>
     * The default value is <code>false</code>.
     *
     * @param pNewState <code>true</code> if error messages should be collected.
     */
    public void enableErrorMessageCollection(boolean pNewState)
    {

        mMessageCollectionEnabled = pNewState;
        if (mMessages == null && mMessageCollectionEnabled)
        {
            mMessages = new ArrayList<String>();
        }
    }

    /**
     * Collects an error message or passes the error message to <code>
     * super.emitErrorMessage(...)</code>.
     * <p/>
     * The actual behaviour depends on whether collecting error messages has been
     * enabled or not.
     *
     * @param pMessage The error message.
     */
    @Override
    public void emitErrorMessage(String pMessage)
    {

        if (mMessageCollectionEnabled)
        {
            mMessages.add(pMessage);
        }
        else
        {
            super.emitErrorMessage(pMessage);
        }
    }

    /**
     * Returns collected error messages.
     * <p/>
     * This methoddecl returns a copy of the internal list of error messages and clears
     * the internal list.
     * <p/>
     * Note that calling this methoddecl eqauls to a <code>getMessages(null)</code>
     * call.
     *
     * @return A list holding collected error messages or <code>null</code> if
     *         collecting error messages is disabled. Of course, the returned list
     *         may be empty if no error message has been emited.
     * @see #getMessages(List)
     */
    public List<String> getMessages()
    {

        return getMessages(null);
    }

    /**
     * Returns collected error messages.
     *
     * @param pUserList If this argument is not <code>null</code> the error
     *                  messages will be added to this list and it's this list that
     *                  will be returned. Otherwise a copy of the internal list of
     *                  error messages will be created and returned. The internal
     *                  list will be cleared just before the methoddecl returns.
     * @return A list holding collected error messages. If collecting error
     *         messages is disabled <code>null</code> will be returned, even if the
     *         argument <code>pUserList</code> is not <code>null</code>.
     */
    public List<String> getMessages(List<String> pUserList)
    {

        if (!mMessageCollectionEnabled)
        {
            return null;
        }
        List<String> result = pUserList;
        if (result == null)
        {
            result = new ArrayList<String>();
        }
        result.addAll(mMessages);
        mMessages.clear();

        return result;
    }

    /**
     * Tells if there is any collected error messages.
     *
     * @return <code>true</code> if there is at least one collected error message.
     */
    public boolean hasErrors()
    {

        return mMessages != null && mMessages.size() > 0;
    }


    public static class javaSource_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "javaSource"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:410:1: javaSource : compilationUnit -> ^( JAVA_SOURCE compilationUnit ) ;

    public final JavaParser.javaSource_return javaSource() throws RecognitionException
    {
        JavaParser.javaSource_return retval = new JavaParser.javaSource_return();
        retval.start = input.LT(1);
        int javaSource_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.compilationUnit_return compilationUnit1 = null;


        RewriteRuleSubtreeStream stream_compilationUnit = new RewriteRuleSubtreeStream(adaptor, "rule compilationUnit");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 1))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:411:5: ( compilationUnit -> ^( JAVA_SOURCE compilationUnit ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:411:9: compilationUnit
            {
                pushFollow(FOLLOW_compilationUnit_in_javaSource4490);
                compilationUnit1 = compilationUnit();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_compilationUnit.add(compilationUnit1.getTree());


                // AST REWRITE
                // elements: compilationUnit
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 412:9: -> ^( JAVA_SOURCE compilationUnit )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:412:13: ^( JAVA_SOURCE compilationUnit )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(JAVA_SOURCE, "JAVA_SOURCE"), root_1);

                            adaptor.addChild(root_1, stream_compilationUnit.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 1, javaSource_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "javaSource"

    public static class compilationUnit_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "compilationUnit"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:415:1: compilationUnit : annotationList ( packageDeclaration )? ( importDeclaration )* ( typeDecls )* ;

    public final JavaParser.compilationUnit_return compilationUnit() throws RecognitionException
    {
        JavaParser.compilationUnit_return retval = new JavaParser.compilationUnit_return();
        retval.start = input.LT(1);
        int compilationUnit_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.annotationList_return annotationList2 = null;

        JavaParser.packageDeclaration_return packageDeclaration3 = null;

        JavaParser.importDeclaration_return importDeclaration4 = null;

        JavaParser.typeDecls_return typeDecls5 = null;


        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 2))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:416:5: ( annotationList ( packageDeclaration )? ( importDeclaration )* ( typeDecls )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:416:9: annotationList ( packageDeclaration )? ( importDeclaration )* ( typeDecls )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_annotationList_in_compilationUnit4526);
                annotationList2 = annotationList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, annotationList2.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:417:9: ( packageDeclaration )?
                int alt1 = 2;
                int LA1_0 = input.LA(1);

                if ((LA1_0 == PACKAGE))
                {
                    alt1 = 1;
                }
                switch (alt1)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: packageDeclaration
                    {
                        pushFollow(FOLLOW_packageDeclaration_in_compilationUnit4536);
                        packageDeclaration3 = packageDeclaration();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, packageDeclaration3.getTree());

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:418:9: ( importDeclaration )*
                loop2:
                do
                {
                    int alt2 = 2;
                    int LA2_0 = input.LA(1);

                    if ((LA2_0 == IMPORT))
                    {
                        alt2 = 1;
                    }


                    switch (alt2)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: importDeclaration
                        {
                            pushFollow(FOLLOW_importDeclaration_in_compilationUnit4547);
                            importDeclaration4 = importDeclaration();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, importDeclaration4.getTree());

                        }
                        break;

                        default:
                            break loop2;
                    }
                }
                while (true);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:419:9: ( typeDecls )*
                loop3:
                do
                {
                    int alt3 = 2;
                    int LA3_0 = input.LA(1);

                    if ((LA3_0 == AT || LA3_0 == LESS_THAN || LA3_0 == SEMI || LA3_0 == ABSTRACT || LA3_0 == BOOLEAN || LA3_0 == BYTE || (LA3_0 >= CHAR && LA3_0 <= CLASS) || LA3_0 == DOUBLE || LA3_0 == ENUM || LA3_0 == FINAL || LA3_0 == FLOAT || LA3_0 == INTERFACE || (LA3_0 >= INT && LA3_0 <= NATIVE) || (LA3_0 >= PRIVATE && LA3_0 <= PUBLIC) || (LA3_0 >= SHORT && LA3_0 <= STRICTFP) || LA3_0 == SYNCHRONIZED || LA3_0 == TRANSIENT || (LA3_0 >= VOID && LA3_0 <= VOLATILE) || LA3_0 == IDENT))
                    {
                        alt3 = 1;
                    }


                    switch (alt3)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: typeDecls
                        {
                            pushFollow(FOLLOW_typeDecls_in_compilationUnit4558);
                            typeDecls5 = typeDecls();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, typeDecls5.getTree());

                        }
                        break;

                        default:
                            break loop3;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 2, compilationUnit_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "compilationUnit"

    public static class typeDecls_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "typeDecls"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:422:1: typeDecls : ( typeDeclaration | SEMI );

    public final JavaParser.typeDecls_return typeDecls() throws RecognitionException
    {
        JavaParser.typeDecls_return retval = new JavaParser.typeDecls_return();
        retval.start = input.LT(1);
        int typeDecls_StartIndex = input.index();
        CommonTree root_0 = null;

        Token SEMI7 = null;
        JavaParser.typeDeclaration_return typeDeclaration6 = null;


        CommonTree SEMI7_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 3))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:423:5: ( typeDeclaration | SEMI )
            int alt4 = 2;
            int LA4_0 = input.LA(1);

            if ((LA4_0 == AT || LA4_0 == LESS_THAN || LA4_0 == ABSTRACT || LA4_0 == BOOLEAN || LA4_0 == BYTE || (LA4_0 >= CHAR && LA4_0 <= CLASS) || LA4_0 == DOUBLE || LA4_0 == ENUM || LA4_0 == FINAL || LA4_0 == FLOAT || LA4_0 == INTERFACE || (LA4_0 >= INT && LA4_0 <= NATIVE) || (LA4_0 >= PRIVATE && LA4_0 <= PUBLIC) || (LA4_0 >= SHORT && LA4_0 <= STRICTFP) || LA4_0 == SYNCHRONIZED || LA4_0 == TRANSIENT || (LA4_0 >= VOID && LA4_0 <= VOLATILE) || LA4_0 == IDENT))
            {
                alt4 = 1;
            }
            else if ((LA4_0 == SEMI))
            {
                alt4 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:423:9: typeDeclaration
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_typeDeclaration_in_typeDecls4578);
                    typeDeclaration6 = typeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, typeDeclaration6.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:424:9: SEMI
                {
                    root_0 = (CommonTree) adaptor.nil();

                    SEMI7 = (Token) match(input, SEMI, FOLLOW_SEMI_in_typeDecls4588);
                    if (state.failed) return retval;

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 3, typeDecls_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "typeDecls"

    public static class packageDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "packageDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:427:1: packageDeclaration : PACKAGE qualifiedIdentifier SEMI ;

    public final JavaParser.packageDeclaration_return packageDeclaration() throws RecognitionException
    {
        JavaParser.packageDeclaration_return retval = new JavaParser.packageDeclaration_return();
        retval.start = input.LT(1);
        int packageDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        Token PACKAGE8 = null;
        Token SEMI10 = null;
        JavaParser.qualifiedIdentifier_return qualifiedIdentifier9 = null;


        CommonTree PACKAGE8_tree = null;
        CommonTree SEMI10_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 4))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:428:5: ( PACKAGE qualifiedIdentifier SEMI )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:428:9: PACKAGE qualifiedIdentifier SEMI
            {
                root_0 = (CommonTree) adaptor.nil();

                PACKAGE8 = (Token) match(input, PACKAGE, FOLLOW_PACKAGE_in_packageDeclaration4608);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    PACKAGE8_tree = (CommonTree) adaptor.create(PACKAGE8);
                    root_0 = (CommonTree) adaptor.becomeRoot(PACKAGE8_tree, root_0);
                }
                pushFollow(FOLLOW_qualifiedIdentifier_in_packageDeclaration4611);
                qualifiedIdentifier9 = qualifiedIdentifier();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, qualifiedIdentifier9.getTree());
                SEMI10 = (Token) match(input, SEMI, FOLLOW_SEMI_in_packageDeclaration4613);
                if (state.failed) return retval;

            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 4, packageDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "packageDeclaration"

    public static class importDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "importDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:431:1: importDeclaration : IMPORT ( STATIC )? qualifiedIdentifier ( DOTSTAR )? SEMI ;

    public final JavaParser.importDeclaration_return importDeclaration() throws RecognitionException
    {
        JavaParser.importDeclaration_return retval = new JavaParser.importDeclaration_return();
        retval.start = input.LT(1);
        int importDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IMPORT11 = null;
        Token STATIC12 = null;
        Token DOTSTAR14 = null;
        Token SEMI15 = null;
        JavaParser.qualifiedIdentifier_return qualifiedIdentifier13 = null;


        CommonTree IMPORT11_tree = null;
        CommonTree STATIC12_tree = null;
        CommonTree DOTSTAR14_tree = null;
        CommonTree SEMI15_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 5))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:432:5: ( IMPORT ( STATIC )? qualifiedIdentifier ( DOTSTAR )? SEMI )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:432:9: IMPORT ( STATIC )? qualifiedIdentifier ( DOTSTAR )? SEMI
            {
                root_0 = (CommonTree) adaptor.nil();

                IMPORT11 = (Token) match(input, IMPORT, FOLLOW_IMPORT_in_importDeclaration4633);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    IMPORT11_tree = (CommonTree) adaptor.create(IMPORT11);
                    root_0 = (CommonTree) adaptor.becomeRoot(IMPORT11_tree, root_0);
                }
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:432:17: ( STATIC )?
                int alt5 = 2;
                int LA5_0 = input.LA(1);

                if ((LA5_0 == STATIC))
                {
                    alt5 = 1;
                }
                switch (alt5)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: STATIC
                    {
                        STATIC12 = (Token) match(input, STATIC, FOLLOW_STATIC_in_importDeclaration4636);
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                        {
                            STATIC12_tree = (CommonTree) adaptor.create(STATIC12);
                            adaptor.addChild(root_0, STATIC12_tree);
                        }

                    }
                    break;

                }

                pushFollow(FOLLOW_qualifiedIdentifier_in_importDeclaration4639);
                qualifiedIdentifier13 = qualifiedIdentifier();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, qualifiedIdentifier13.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:432:45: ( DOTSTAR )?
                int alt6 = 2;
                int LA6_0 = input.LA(1);

                if ((LA6_0 == DOTSTAR))
                {
                    alt6 = 1;
                }
                switch (alt6)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: DOTSTAR
                    {
                        DOTSTAR14 = (Token) match(input, DOTSTAR, FOLLOW_DOTSTAR_in_importDeclaration4641);
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                        {
                            DOTSTAR14_tree = (CommonTree) adaptor.create(DOTSTAR14);
                            adaptor.addChild(root_0, DOTSTAR14_tree);
                        }

                    }
                    break;

                }

                SEMI15 = (Token) match(input, SEMI, FOLLOW_SEMI_in_importDeclaration4644);
                if (state.failed) return retval;

            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 5, importDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "importDeclaration"

    public static class typeDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "typeDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:435:1: typeDeclaration : modifierList ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] ) ;

    public final JavaParser.typeDeclaration_return typeDeclaration() throws RecognitionException
    {
        JavaParser.typeDeclaration_return retval = new JavaParser.typeDeclaration_return();
        retval.start = input.LT(1);
        int typeDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.modifierList_return modifierList16 = null;

        JavaParser.classTypeDeclaration_return classTypeDeclaration17 = null;

        JavaParser.interfaceTypeDeclaration_return interfaceTypeDeclaration18 = null;

        JavaParser.enumTypeDeclaration_return enumTypeDeclaration19 = null;

        JavaParser.annotationTypeDeclaration_return annotationTypeDeclaration20 = null;


        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 6))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:436:5: ( modifierList ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:436:9: modifierList ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] )
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_modifierList_in_typeDeclaration4664);
                modifierList16 = modifierList();

                state._fsp--;
                if (state.failed) return retval;
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:437:9: ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] )
                int alt7 = 4;
                switch (input.LA(1))
                {
                    case CLASS:
                    {
                        alt7 = 1;
                    }
                    break;
                    case INTERFACE:
                    {
                        alt7 = 2;
                    }
                    break;
                    case ENUM:
                    {
                        alt7 = 3;
                    }
                    break;
                    case AT:
                    {
                        alt7 = 4;
                    }
                    break;
                    default:
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 7, 0, input);

                        throw nvae;
                }

                switch (alt7)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:437:13: classTypeDeclaration[$modifierList.tree]
                    {
                        pushFollow(FOLLOW_classTypeDeclaration_in_typeDeclaration4679);
                        classTypeDeclaration17 = classTypeDeclaration((modifierList16 != null ? ((CommonTree) modifierList16.tree) : null));

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, classTypeDeclaration17.getTree());

                    }
                    break;
                    case 2:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:438:13: interfaceTypeDeclaration[$modifierList.tree]
                    {
                        pushFollow(FOLLOW_interfaceTypeDeclaration_in_typeDeclaration4694);
                        interfaceTypeDeclaration18 = interfaceTypeDeclaration((modifierList16 != null ? ((CommonTree) modifierList16.tree) : null));

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, interfaceTypeDeclaration18.getTree());

                    }
                    break;
                    case 3:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:439:13: enumTypeDeclaration[$modifierList.tree]
                    {
                        pushFollow(FOLLOW_enumTypeDeclaration_in_typeDeclaration4709);
                        enumTypeDeclaration19 = enumTypeDeclaration((modifierList16 != null ? ((CommonTree) modifierList16.tree) : null));

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, enumTypeDeclaration19.getTree());

                    }
                    break;
                    case 4:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:440:13: annotationTypeDeclaration[$modifierList.tree]
                    {
                        pushFollow(FOLLOW_annotationTypeDeclaration_in_typeDeclaration4724);
                        annotationTypeDeclaration20 = annotationTypeDeclaration((modifierList16 != null ? ((CommonTree) modifierList16.tree) : null));

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, annotationTypeDeclaration20.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 6, typeDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "typeDeclaration"

    public static class classTypeDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "classTypeDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:444:1: classTypeDeclaration[CommonTree modifiers] : CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody -> ^( CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody ) ;

    public final JavaParser.classTypeDeclaration_return classTypeDeclaration(CommonTree modifiers) throws RecognitionException
    {
        JavaParser.classTypeDeclaration_return retval = new JavaParser.classTypeDeclaration_return();
        retval.start = input.LT(1);
        int classTypeDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        Token CLASS21 = null;
        Token IDENT22 = null;
        JavaParser.genericTypeParameterList_return genericTypeParameterList23 = null;

        JavaParser.classExtendsClause_return classExtendsClause24 = null;

        JavaParser.implementsClause_return implementsClause25 = null;

        JavaParser.classBody_return classBody26 = null;


        CommonTree CLASS21_tree = null;
        CommonTree IDENT22_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_CLASS = new RewriteRuleTokenStream(adaptor, "token CLASS");
        RewriteRuleSubtreeStream stream_genericTypeParameterList = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeParameterList");
        RewriteRuleSubtreeStream stream_classExtendsClause = new RewriteRuleSubtreeStream(adaptor, "rule classExtendsClause");
        RewriteRuleSubtreeStream stream_implementsClause = new RewriteRuleSubtreeStream(adaptor, "rule implementsClause");
        RewriteRuleSubtreeStream stream_classBody = new RewriteRuleSubtreeStream(adaptor, "rule classBody");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 7))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:445:5: ( CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody -> ^( CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:445:9: CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody
            {
                CLASS21 = (Token) match(input, CLASS, FOLLOW_CLASS_in_classTypeDeclaration4755);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_CLASS.add(CLASS21);

                IDENT22 = (Token) match(input, IDENT, FOLLOW_IDENT_in_classTypeDeclaration4757);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IDENT.add(IDENT22);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:445:21: ( genericTypeParameterList )?
                int alt8 = 2;
                int LA8_0 = input.LA(1);

                if ((LA8_0 == LESS_THAN))
                {
                    alt8 = 1;
                }
                switch (alt8)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                    {
                        pushFollow(FOLLOW_genericTypeParameterList_in_classTypeDeclaration4759);
                        genericTypeParameterList23 = genericTypeParameterList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_genericTypeParameterList.add(genericTypeParameterList23.getTree());

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:445:47: ( classExtendsClause )?
                int alt9 = 2;
                int LA9_0 = input.LA(1);

                if ((LA9_0 == EXTENDS))
                {
                    alt9 = 1;
                }
                switch (alt9)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: classExtendsClause
                    {
                        pushFollow(FOLLOW_classExtendsClause_in_classTypeDeclaration4762);
                        classExtendsClause24 = classExtendsClause();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_classExtendsClause.add(classExtendsClause24.getTree());

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:445:67: ( implementsClause )?
                int alt10 = 2;
                int LA10_0 = input.LA(1);

                if ((LA10_0 == IMPLEMENTS))
                {
                    alt10 = 1;
                }
                switch (alt10)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: implementsClause
                    {
                        pushFollow(FOLLOW_implementsClause_in_classTypeDeclaration4765);
                        implementsClause25 = implementsClause();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_implementsClause.add(implementsClause25.getTree());

                    }
                    break;

                }

                pushFollow(FOLLOW_classBody_in_classTypeDeclaration4768);
                classBody26 = classBody();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_classBody.add(classBody26.getTree());


                // AST REWRITE
                // elements: classExtendsClause, classBody, IDENT, CLASS, implementsClause, genericTypeParameterList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 446:9: -> ^( CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:446:13: ^( CLASS IDENT ( genericTypeParameterList )? ( classExtendsClause )? ( implementsClause )? classBody )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot(stream_CLASS.nextNode(), root_1);

                            adaptor.addChild(root_1, modifiers);
                            adaptor.addChild(root_1, stream_IDENT.nextNode());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:446:40: ( genericTypeParameterList )?
                            if (stream_genericTypeParameterList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                            }
                            stream_genericTypeParameterList.reset();
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:446:66: ( classExtendsClause )?
                            if (stream_classExtendsClause.hasNext())
                            {
                                adaptor.addChild(root_1, stream_classExtendsClause.nextTree());

                            }
                            stream_classExtendsClause.reset();
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:446:86: ( implementsClause )?
                            if (stream_implementsClause.hasNext())
                            {
                                adaptor.addChild(root_1, stream_implementsClause.nextTree());

                            }
                            stream_implementsClause.reset();
                            adaptor.addChild(root_1, stream_classBody.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 7, classTypeDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "classTypeDeclaration"

    public static class classExtendsClause_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "classExtendsClause"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:449:1: classExtendsClause : EXTENDS type -> ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] type ) ;

    public final JavaParser.classExtendsClause_return classExtendsClause() throws RecognitionException
    {
        JavaParser.classExtendsClause_return retval = new JavaParser.classExtendsClause_return();
        retval.start = input.LT(1);
        int classExtendsClause_StartIndex = input.index();
        CommonTree root_0 = null;

        Token EXTENDS27 = null;
        JavaParser.type_return type28 = null;


        CommonTree EXTENDS27_tree = null;
        RewriteRuleTokenStream stream_EXTENDS = new RewriteRuleTokenStream(adaptor, "token EXTENDS");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 8))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:450:5: ( EXTENDS type -> ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] type ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:450:9: EXTENDS type
            {
                EXTENDS27 = (Token) match(input, EXTENDS, FOLLOW_EXTENDS_in_classExtendsClause4817);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_EXTENDS.add(EXTENDS27);

                pushFollow(FOLLOW_type_in_classExtendsClause4819);
                type28 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_type.add(type28.getTree());


                // AST REWRITE
                // elements: type
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 451:9: -> ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] type )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:451:13: ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] type )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(EXTENDS_CLAUSE, EXTENDS27, "EXTENDS_CLAUSE"), root_1);

                            adaptor.addChild(root_1, stream_type.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 8, classExtendsClause_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "classExtendsClause"

    public static class interfaceExtendsClause_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "interfaceExtendsClause"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:454:1: interfaceExtendsClause : EXTENDS typeList -> ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] typeList ) ;

    public final JavaParser.interfaceExtendsClause_return interfaceExtendsClause() throws RecognitionException
    {
        JavaParser.interfaceExtendsClause_return retval = new JavaParser.interfaceExtendsClause_return();
        retval.start = input.LT(1);
        int interfaceExtendsClause_StartIndex = input.index();
        CommonTree root_0 = null;

        Token EXTENDS29 = null;
        JavaParser.typeList_return typeList30 = null;


        CommonTree EXTENDS29_tree = null;
        RewriteRuleTokenStream stream_EXTENDS = new RewriteRuleTokenStream(adaptor, "token EXTENDS");
        RewriteRuleSubtreeStream stream_typeList = new RewriteRuleSubtreeStream(adaptor, "rule typeList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 9))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:455:5: ( EXTENDS typeList -> ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] typeList ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:455:9: EXTENDS typeList
            {
                EXTENDS29 = (Token) match(input, EXTENDS, FOLLOW_EXTENDS_in_interfaceExtendsClause4856);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_EXTENDS.add(EXTENDS29);

                pushFollow(FOLLOW_typeList_in_interfaceExtendsClause4858);
                typeList30 = typeList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_typeList.add(typeList30.getTree());


                // AST REWRITE
                // elements: typeList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 456:9: -> ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] typeList )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:456:13: ^( EXTENDS_CLAUSE[$EXTENDS, \"EXTENDS_CLAUSE\"] typeList )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(EXTENDS_CLAUSE, EXTENDS29, "EXTENDS_CLAUSE"), root_1);

                            adaptor.addChild(root_1, stream_typeList.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 9, interfaceExtendsClause_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "interfaceExtendsClause"

    public static class implementsClause_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "implementsClause"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:459:1: implementsClause : IMPLEMENTS typeList -> ^( IMPLEMENTS_CLAUSE[$IMPLEMENTS, \"IMPLEMENTS_CLAUSE\"] typeList ) ;

    public final JavaParser.implementsClause_return implementsClause() throws RecognitionException
    {
        JavaParser.implementsClause_return retval = new JavaParser.implementsClause_return();
        retval.start = input.LT(1);
        int implementsClause_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IMPLEMENTS31 = null;
        JavaParser.typeList_return typeList32 = null;


        CommonTree IMPLEMENTS31_tree = null;
        RewriteRuleTokenStream stream_IMPLEMENTS = new RewriteRuleTokenStream(adaptor, "token IMPLEMENTS");
        RewriteRuleSubtreeStream stream_typeList = new RewriteRuleSubtreeStream(adaptor, "rule typeList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 10))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:460:5: ( IMPLEMENTS typeList -> ^( IMPLEMENTS_CLAUSE[$IMPLEMENTS, \"IMPLEMENTS_CLAUSE\"] typeList ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:460:9: IMPLEMENTS typeList
            {
                IMPLEMENTS31 = (Token) match(input, IMPLEMENTS, FOLLOW_IMPLEMENTS_in_implementsClause4895);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IMPLEMENTS.add(IMPLEMENTS31);

                pushFollow(FOLLOW_typeList_in_implementsClause4897);
                typeList32 = typeList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_typeList.add(typeList32.getTree());


                // AST REWRITE
                // elements: typeList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 461:9: -> ^( IMPLEMENTS_CLAUSE[$IMPLEMENTS, \"IMPLEMENTS_CLAUSE\"] typeList )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:461:13: ^( IMPLEMENTS_CLAUSE[$IMPLEMENTS, \"IMPLEMENTS_CLAUSE\"] typeList )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(IMPLEMENTS_CLAUSE, IMPLEMENTS31, "IMPLEMENTS_CLAUSE"), root_1);

                            adaptor.addChild(root_1, stream_typeList.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 10, implementsClause_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "implementsClause"

    public static class genericTypeParameterList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeParameterList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:464:1: genericTypeParameterList : LESS_THAN genericTypeParameter ( COMMA genericTypeParameter )* genericTypeListClosing -> ^( GENERIC_TYPE_PARAM_LIST[$LESS_THAN, \"GENERIC_TYPE_PARAM_LIST\"] ( genericTypeParameter )+ ) ;

    public final JavaParser.genericTypeParameterList_return genericTypeParameterList() throws RecognitionException
    {
        JavaParser.genericTypeParameterList_return retval = new JavaParser.genericTypeParameterList_return();
        retval.start = input.LT(1);
        int genericTypeParameterList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LESS_THAN33 = null;
        Token COMMA35 = null;
        JavaParser.genericTypeParameter_return genericTypeParameter34 = null;

        JavaParser.genericTypeParameter_return genericTypeParameter36 = null;

        JavaParser.genericTypeListClosing_return genericTypeListClosing37 = null;


        CommonTree LESS_THAN33_tree = null;
        CommonTree COMMA35_tree = null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleTokenStream stream_LESS_THAN = new RewriteRuleTokenStream(adaptor, "token LESS_THAN");
        RewriteRuleSubtreeStream stream_genericTypeParameter = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeParameter");
        RewriteRuleSubtreeStream stream_genericTypeListClosing = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeListClosing");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 11))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:465:5: ( LESS_THAN genericTypeParameter ( COMMA genericTypeParameter )* genericTypeListClosing -> ^( GENERIC_TYPE_PARAM_LIST[$LESS_THAN, \"GENERIC_TYPE_PARAM_LIST\"] ( genericTypeParameter )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:465:9: LESS_THAN genericTypeParameter ( COMMA genericTypeParameter )* genericTypeListClosing
            {
                LESS_THAN33 = (Token) match(input, LESS_THAN, FOLLOW_LESS_THAN_in_genericTypeParameterList4934);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LESS_THAN.add(LESS_THAN33);

                pushFollow(FOLLOW_genericTypeParameter_in_genericTypeParameterList4936);
                genericTypeParameter34 = genericTypeParameter();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_genericTypeParameter.add(genericTypeParameter34.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:465:40: ( COMMA genericTypeParameter )*
                loop11:
                do
                {
                    int alt11 = 2;
                    int LA11_0 = input.LA(1);

                    if ((LA11_0 == COMMA))
                    {
                        alt11 = 1;
                    }


                    switch (alt11)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:465:41: COMMA genericTypeParameter
                        {
                            COMMA35 = (Token) match(input, COMMA, FOLLOW_COMMA_in_genericTypeParameterList4939);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COMMA.add(COMMA35);

                            pushFollow(FOLLOW_genericTypeParameter_in_genericTypeParameterList4941);
                            genericTypeParameter36 = genericTypeParameter();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_genericTypeParameter.add(genericTypeParameter36.getTree());

                        }
                        break;

                        default:
                            break loop11;
                    }
                }
                while (true);

                pushFollow(FOLLOW_genericTypeListClosing_in_genericTypeParameterList4945);
                genericTypeListClosing37 = genericTypeListClosing();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_genericTypeListClosing.add(genericTypeListClosing37.getTree());


                // AST REWRITE
                // elements: genericTypeParameter
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 466:9: -> ^( GENERIC_TYPE_PARAM_LIST[$LESS_THAN, \"GENERIC_TYPE_PARAM_LIST\"] ( genericTypeParameter )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:466:13: ^( GENERIC_TYPE_PARAM_LIST[$LESS_THAN, \"GENERIC_TYPE_PARAM_LIST\"] ( genericTypeParameter )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(GENERIC_TYPE_PARAM_LIST, LESS_THAN33, "GENERIC_TYPE_PARAM_LIST"), root_1);

                            if (!(stream_genericTypeParameter.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_genericTypeParameter.hasNext())
                            {
                                adaptor.addChild(root_1, stream_genericTypeParameter.nextTree());

                            }
                            stream_genericTypeParameter.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 11, genericTypeParameterList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeParameterList"

    public static class genericTypeListClosing_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeListClosing"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:469:1: genericTypeListClosing : ( GREATER_THAN | SHIFT_RIGHT | BIT_SHIFT_RIGHT | );

    public final JavaParser.genericTypeListClosing_return genericTypeListClosing() throws RecognitionException
    {
        JavaParser.genericTypeListClosing_return retval = new JavaParser.genericTypeListClosing_return();
        retval.start = input.LT(1);
        int genericTypeListClosing_StartIndex = input.index();
        CommonTree root_0 = null;

        Token GREATER_THAN38 = null;
        Token SHIFT_RIGHT39 = null;
        Token BIT_SHIFT_RIGHT40 = null;

        CommonTree GREATER_THAN38_tree = null;
        CommonTree SHIFT_RIGHT39_tree = null;
        CommonTree BIT_SHIFT_RIGHT40_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 12))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:473:5: ( GREATER_THAN | SHIFT_RIGHT | BIT_SHIFT_RIGHT | )
            int alt12 = 4;
            switch (input.LA(1))
            {
                case GREATER_THAN:
                {
                    int LA12_1 = input.LA(2);

                    if ((synpred14_Java()))
                    {
                        alt12 = 1;
                    }
                    else if ((true))
                    {
                        alt12 = 4;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 12, 1, input);

                        throw nvae;
                    }
                }
                break;
                case SHIFT_RIGHT:
                {
                    int LA12_2 = input.LA(2);

                    if ((synpred15_Java()))
                    {
                        alt12 = 2;
                    }
                    else if ((true))
                    {
                        alt12 = 4;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 12, 2, input);

                        throw nvae;
                    }
                }
                break;
                case BIT_SHIFT_RIGHT:
                {
                    int LA12_3 = input.LA(2);

                    if ((synpred16_Java()))
                    {
                        alt12 = 3;
                    }
                    else if ((true))
                    {
                        alt12 = 4;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 12, 3, input);

                        throw nvae;
                    }
                }
                break;
                case EOF:
                case AND:
                case AND_ASSIGN:
                case ASSIGN:
                case BIT_SHIFT_RIGHT_ASSIGN:
                case COLON:
                case COMMA:
                case DIV_ASSIGN:
                case DOT:
                case ELLIPSIS:
                case EQUAL:
                case LBRACK:
                case LCURLY:
                case LOGICAL_AND:
                case LOGICAL_OR:
                case LPAREN:
                case MINUS_ASSIGN:
                case MOD_ASSIGN:
                case NOT_EQUAL:
                case OR:
                case OR_ASSIGN:
                case PLUS_ASSIGN:
                case QUESTION:
                case RBRACK:
                case RCURLY:
                case RPAREN:
                case SEMI:
                case SHIFT_LEFT_ASSIGN:
                case SHIFT_RIGHT_ASSIGN:
                case STAR_ASSIGN:
                case XOR:
                case XOR_ASSIGN:
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case EXTENDS:
                case FLOAT:
                case IMPLEMENTS:
                case INT:
                case LONG:
                case SHORT:
                case SUPER:
                case THIS:
                case VOID:
                case IDENT:
                {
                    alt12 = 4;
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 12, 0, input);

                    throw nvae;
            }

            switch (alt12)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:473:9: GREATER_THAN
                {
                    root_0 = (CommonTree) adaptor.nil();

                    GREATER_THAN38 = (Token) match(input, GREATER_THAN, FOLLOW_GREATER_THAN_in_genericTypeListClosing5060);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        GREATER_THAN38_tree = (CommonTree) adaptor.create(GREATER_THAN38);
                        adaptor.addChild(root_0, GREATER_THAN38_tree);
                    }

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:474:9: SHIFT_RIGHT
                {
                    root_0 = (CommonTree) adaptor.nil();

                    SHIFT_RIGHT39 = (Token) match(input, SHIFT_RIGHT, FOLLOW_SHIFT_RIGHT_in_genericTypeListClosing5070);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        SHIFT_RIGHT39_tree = (CommonTree) adaptor.create(SHIFT_RIGHT39);
                        adaptor.addChild(root_0, SHIFT_RIGHT39_tree);
                    }

                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:475:9: BIT_SHIFT_RIGHT
                {
                    root_0 = (CommonTree) adaptor.nil();

                    BIT_SHIFT_RIGHT40 = (Token) match(input, BIT_SHIFT_RIGHT, FOLLOW_BIT_SHIFT_RIGHT_in_genericTypeListClosing5080);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        BIT_SHIFT_RIGHT40_tree = (CommonTree) adaptor.create(BIT_SHIFT_RIGHT40);
                        adaptor.addChild(root_0, BIT_SHIFT_RIGHT40_tree);
                    }

                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:477:5: 
                {
                    root_0 = (CommonTree) adaptor.nil();

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 12, genericTypeListClosing_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeListClosing"

    public static class genericTypeParameter_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeParameter"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:479:1: genericTypeParameter : IDENT ( bound )? -> ^( IDENT ( bound )? ) ;

    public final JavaParser.genericTypeParameter_return genericTypeParameter() throws RecognitionException
    {
        JavaParser.genericTypeParameter_return retval = new JavaParser.genericTypeParameter_return();
        retval.start = input.LT(1);
        int genericTypeParameter_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT41 = null;
        JavaParser.bound_return bound42 = null;


        CommonTree IDENT41_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleSubtreeStream stream_bound = new RewriteRuleSubtreeStream(adaptor, "rule bound");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 13))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:480:5: ( IDENT ( bound )? -> ^( IDENT ( bound )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:480:9: IDENT ( bound )?
            {
                IDENT41 = (Token) match(input, IDENT, FOLLOW_IDENT_in_genericTypeParameter5108);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IDENT.add(IDENT41);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:480:15: ( bound )?
                int alt13 = 2;
                int LA13_0 = input.LA(1);

                if ((LA13_0 == EXTENDS))
                {
                    int LA13_1 = input.LA(2);

                    if ((LA13_1 == BOOLEAN || LA13_1 == BYTE || LA13_1 == CHAR || LA13_1 == DOUBLE || LA13_1 == FLOAT || (LA13_1 >= INT && LA13_1 <= LONG) || LA13_1 == SHORT))
                    {
                        int LA13_3 = input.LA(3);

                        if ((synpred17_Java()))
                        {
                            alt13 = 1;
                        }
                    }
                    else if ((LA13_1 == IDENT))
                    {
                        int LA13_4 = input.LA(3);

                        if ((synpred17_Java()))
                        {
                            alt13 = 1;
                        }
                    }
                }
                switch (alt13)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: bound
                    {
                        pushFollow(FOLLOW_bound_in_genericTypeParameter5110);
                        bound42 = bound();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_bound.add(bound42.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: IDENT, bound
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 481:9: -> ^( IDENT ( bound )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:481:13: ^( IDENT ( bound )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot(stream_IDENT.nextNode(), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:481:21: ( bound )?
                            if (stream_bound.hasNext())
                            {
                                adaptor.addChild(root_1, stream_bound.nextTree());

                            }
                            stream_bound.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 13, genericTypeParameter_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeParameter"

    public static class bound_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "bound"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:484:1: bound : EXTENDS type ( AND type )* -> ^( EXTENDS_BOUND_LIST[$EXTENDS, \"EXTENDS_BOUND_LIST\"] ( type )+ ) ;

    public final JavaParser.bound_return bound() throws RecognitionException
    {
        JavaParser.bound_return retval = new JavaParser.bound_return();
        retval.start = input.LT(1);
        int bound_StartIndex = input.index();
        CommonTree root_0 = null;

        Token EXTENDS43 = null;
        Token AND45 = null;
        JavaParser.type_return type44 = null;

        JavaParser.type_return type46 = null;


        CommonTree EXTENDS43_tree = null;
        CommonTree AND45_tree = null;
        RewriteRuleTokenStream stream_AND = new RewriteRuleTokenStream(adaptor, "token AND");
        RewriteRuleTokenStream stream_EXTENDS = new RewriteRuleTokenStream(adaptor, "token EXTENDS");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 14))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:485:5: ( EXTENDS type ( AND type )* -> ^( EXTENDS_BOUND_LIST[$EXTENDS, \"EXTENDS_BOUND_LIST\"] ( type )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:485:9: EXTENDS type ( AND type )*
            {
                EXTENDS43 = (Token) match(input, EXTENDS, FOLLOW_EXTENDS_in_bound5148);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_EXTENDS.add(EXTENDS43);

                pushFollow(FOLLOW_type_in_bound5150);
                type44 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_type.add(type44.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:485:22: ( AND type )*
                loop14:
                do
                {
                    int alt14 = 2;
                    int LA14_0 = input.LA(1);

                    if ((LA14_0 == AND))
                    {
                        alt14 = 1;
                    }


                    switch (alt14)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:485:23: AND type
                        {
                            AND45 = (Token) match(input, AND, FOLLOW_AND_in_bound5153);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_AND.add(AND45);

                            pushFollow(FOLLOW_type_in_bound5155);
                            type46 = type();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_type.add(type46.getTree());

                        }
                        break;

                        default:
                            break loop14;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: type
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 486:9: -> ^( EXTENDS_BOUND_LIST[$EXTENDS, \"EXTENDS_BOUND_LIST\"] ( type )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:486:13: ^( EXTENDS_BOUND_LIST[$EXTENDS, \"EXTENDS_BOUND_LIST\"] ( type )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(EXTENDS_BOUND_LIST, EXTENDS43, "EXTENDS_BOUND_LIST"), root_1);

                            if (!(stream_type.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_type.hasNext())
                            {
                                adaptor.addChild(root_1, stream_type.nextTree());

                            }
                            stream_type.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 14, bound_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "bound"

    public static class enumTypeDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "enumTypeDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:489:1: enumTypeDeclaration[CommonTree modifiers] : ENUM IDENT ( implementsClause )? enumBody -> ^( ENUM IDENT ( implementsClause )? enumBody ) ;

    public final JavaParser.enumTypeDeclaration_return enumTypeDeclaration(CommonTree modifiers) throws RecognitionException
    {
        JavaParser.enumTypeDeclaration_return retval = new JavaParser.enumTypeDeclaration_return();
        retval.start = input.LT(1);
        int enumTypeDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ENUM47 = null;
        Token IDENT48 = null;
        JavaParser.implementsClause_return implementsClause49 = null;

        JavaParser.enumBody_return enumBody50 = null;


        CommonTree ENUM47_tree = null;
        CommonTree IDENT48_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_ENUM = new RewriteRuleTokenStream(adaptor, "token ENUM");
        RewriteRuleSubtreeStream stream_implementsClause = new RewriteRuleSubtreeStream(adaptor, "rule implementsClause");
        RewriteRuleSubtreeStream stream_enumBody = new RewriteRuleSubtreeStream(adaptor, "rule enumBody");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 15))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:490:5: ( ENUM IDENT ( implementsClause )? enumBody -> ^( ENUM IDENT ( implementsClause )? enumBody ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:490:9: ENUM IDENT ( implementsClause )? enumBody
            {
                ENUM47 = (Token) match(input, ENUM, FOLLOW_ENUM_in_enumTypeDeclaration5196);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_ENUM.add(ENUM47);

                IDENT48 = (Token) match(input, IDENT, FOLLOW_IDENT_in_enumTypeDeclaration5198);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IDENT.add(IDENT48);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:490:20: ( implementsClause )?
                int alt15 = 2;
                int LA15_0 = input.LA(1);

                if ((LA15_0 == IMPLEMENTS))
                {
                    alt15 = 1;
                }
                switch (alt15)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: implementsClause
                    {
                        pushFollow(FOLLOW_implementsClause_in_enumTypeDeclaration5200);
                        implementsClause49 = implementsClause();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_implementsClause.add(implementsClause49.getTree());

                    }
                    break;

                }

                pushFollow(FOLLOW_enumBody_in_enumTypeDeclaration5203);
                enumBody50 = enumBody();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_enumBody.add(enumBody50.getTree());


                // AST REWRITE
                // elements: enumBody, ENUM, IDENT, implementsClause
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 491:9: -> ^( ENUM IDENT ( implementsClause )? enumBody )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:491:13: ^( ENUM IDENT ( implementsClause )? enumBody )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot(stream_ENUM.nextNode(), root_1);

                            adaptor.addChild(root_1, modifiers);
                            adaptor.addChild(root_1, stream_IDENT.nextNode());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:491:39: ( implementsClause )?
                            if (stream_implementsClause.hasNext())
                            {
                                adaptor.addChild(root_1, stream_implementsClause.nextTree());

                            }
                            stream_implementsClause.reset();
                            adaptor.addChild(root_1, stream_enumBody.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 15, enumTypeDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "enumTypeDeclaration"

    public static class enumBody_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "enumBody"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:494:1: enumBody : LCURLY enumScopeDeclarations RCURLY -> ^( ENUM_TOP_LEVEL_SCOPE[$LCURLY, \"ENUM_TOP_LEVEL_SCOPE\"] enumScopeDeclarations ) ;

    public final JavaParser.enumBody_return enumBody() throws RecognitionException
    {
        JavaParser.enumBody_return retval = new JavaParser.enumBody_return();
        retval.start = input.LT(1);
        int enumBody_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY51 = null;
        Token RCURLY53 = null;
        JavaParser.enumScopeDeclarations_return enumScopeDeclarations52 = null;


        CommonTree LCURLY51_tree = null;
        CommonTree RCURLY53_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_enumScopeDeclarations = new RewriteRuleSubtreeStream(adaptor, "rule enumScopeDeclarations");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 16))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:495:5: ( LCURLY enumScopeDeclarations RCURLY -> ^( ENUM_TOP_LEVEL_SCOPE[$LCURLY, \"ENUM_TOP_LEVEL_SCOPE\"] enumScopeDeclarations ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:495:9: LCURLY enumScopeDeclarations RCURLY
            {
                LCURLY51 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_enumBody5246);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY51);

                pushFollow(FOLLOW_enumScopeDeclarations_in_enumBody5248);
                enumScopeDeclarations52 = enumScopeDeclarations();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_enumScopeDeclarations.add(enumScopeDeclarations52.getTree());
                RCURLY53 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_enumBody5250);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY53);


                // AST REWRITE
                // elements: enumScopeDeclarations
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 496:9: -> ^( ENUM_TOP_LEVEL_SCOPE[$LCURLY, \"ENUM_TOP_LEVEL_SCOPE\"] enumScopeDeclarations )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:496:13: ^( ENUM_TOP_LEVEL_SCOPE[$LCURLY, \"ENUM_TOP_LEVEL_SCOPE\"] enumScopeDeclarations )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ENUM_TOP_LEVEL_SCOPE, LCURLY51, "ENUM_TOP_LEVEL_SCOPE"), root_1);

                            adaptor.addChild(root_1, stream_enumScopeDeclarations.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 16, enumBody_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "enumBody"

    public static class enumScopeDeclarations_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "enumScopeDeclarations"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:499:1: enumScopeDeclarations : ( enumConstants )? ( COMMA )? ( enumClassScopeDeclarations )? ;

    public final JavaParser.enumScopeDeclarations_return enumScopeDeclarations() throws RecognitionException
    {
        JavaParser.enumScopeDeclarations_return retval = new JavaParser.enumScopeDeclarations_return();
        retval.start = input.LT(1);
        int enumScopeDeclarations_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA55 = null;
        JavaParser.enumConstants_return enumConstants54 = null;

        JavaParser.enumClassScopeDeclarations_return enumClassScopeDeclarations56 = null;


        CommonTree COMMA55_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 17))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:500:5: ( ( enumConstants )? ( COMMA )? ( enumClassScopeDeclarations )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:500:9: ( enumConstants )? ( COMMA )? ( enumClassScopeDeclarations )?
            {
                root_0 = (CommonTree) adaptor.nil();

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:500:9: ( enumConstants )?
                int alt16 = 2;
                int LA16_0 = input.LA(1);

                if ((LA16_0 == AT || LA16_0 == IDENT))
                {
                    alt16 = 1;
                }
                switch (alt16)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: enumConstants
                    {
                        pushFollow(FOLLOW_enumConstants_in_enumScopeDeclarations5287);
                        enumConstants54 = enumConstants();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, enumConstants54.getTree());

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:500:24: ( COMMA )?
                int alt17 = 2;
                int LA17_0 = input.LA(1);

                if ((LA17_0 == COMMA))
                {
                    alt17 = 1;
                }
                switch (alt17)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:500:25: COMMA
                    {
                        COMMA55 = (Token) match(input, COMMA, FOLLOW_COMMA_in_enumScopeDeclarations5291);
                        if (state.failed) return retval;

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:500:34: ( enumClassScopeDeclarations )?
                int alt18 = 2;
                int LA18_0 = input.LA(1);

                if ((LA18_0 == SEMI))
                {
                    alt18 = 1;
                }
                switch (alt18)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: enumClassScopeDeclarations
                    {
                        pushFollow(FOLLOW_enumClassScopeDeclarations_in_enumScopeDeclarations5296);
                        enumClassScopeDeclarations56 = enumClassScopeDeclarations();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, enumClassScopeDeclarations56.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 17, enumScopeDeclarations_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "enumScopeDeclarations"

    public static class enumClassScopeDeclarations_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "enumClassScopeDeclarations"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:503:1: enumClassScopeDeclarations : SEMI ( classScopeDeclarations )* -> ^( CLASS_TOP_LEVEL_SCOPE[$SEMI, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* ) ;

    public final JavaParser.enumClassScopeDeclarations_return enumClassScopeDeclarations() throws RecognitionException
    {
        JavaParser.enumClassScopeDeclarations_return retval = new JavaParser.enumClassScopeDeclarations_return();
        retval.start = input.LT(1);
        int enumClassScopeDeclarations_StartIndex = input.index();
        CommonTree root_0 = null;

        Token SEMI57 = null;
        JavaParser.classScopeDeclarations_return classScopeDeclarations58 = null;


        CommonTree SEMI57_tree = null;
        RewriteRuleTokenStream stream_SEMI = new RewriteRuleTokenStream(adaptor, "token SEMI");
        RewriteRuleSubtreeStream stream_classScopeDeclarations = new RewriteRuleSubtreeStream(adaptor, "rule classScopeDeclarations");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 18))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:504:5: ( SEMI ( classScopeDeclarations )* -> ^( CLASS_TOP_LEVEL_SCOPE[$SEMI, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:504:9: SEMI ( classScopeDeclarations )*
            {
                SEMI57 = (Token) match(input, SEMI, FOLLOW_SEMI_in_enumClassScopeDeclarations5316);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_SEMI.add(SEMI57);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:504:14: ( classScopeDeclarations )*
                loop19:
                do
                {
                    int alt19 = 2;
                    int LA19_0 = input.LA(1);

                    if ((LA19_0 == AT || LA19_0 == LCURLY || LA19_0 == LESS_THAN || LA19_0 == SEMI || LA19_0 == ABSTRACT || LA19_0 == BOOLEAN || LA19_0 == BYTE || (LA19_0 >= CHAR && LA19_0 <= CLASS) || LA19_0 == DOUBLE || LA19_0 == ENUM || LA19_0 == FINAL || LA19_0 == FLOAT || LA19_0 == INTERFACE || (LA19_0 >= INT && LA19_0 <= NATIVE) || (LA19_0 >= PRIVATE && LA19_0 <= PUBLIC) || (LA19_0 >= SHORT && LA19_0 <= STRICTFP) || LA19_0 == SYNCHRONIZED || LA19_0 == TRANSIENT || (LA19_0 >= VOID && LA19_0 <= VOLATILE) || LA19_0 == IDENT))
                    {
                        alt19 = 1;
                    }


                    switch (alt19)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: classScopeDeclarations
                        {
                            pushFollow(FOLLOW_classScopeDeclarations_in_enumClassScopeDeclarations5318);
                            classScopeDeclarations58 = classScopeDeclarations();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_classScopeDeclarations.add(classScopeDeclarations58.getTree());

                        }
                        break;

                        default:
                            break loop19;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: classScopeDeclarations
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 505:9: -> ^( CLASS_TOP_LEVEL_SCOPE[$SEMI, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:505:13: ^( CLASS_TOP_LEVEL_SCOPE[$SEMI, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CLASS_TOP_LEVEL_SCOPE, SEMI57, "CLASS_TOP_LEVEL_SCOPE"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:505:69: ( classScopeDeclarations )*
                            while (stream_classScopeDeclarations.hasNext())
                            {
                                adaptor.addChild(root_1, stream_classScopeDeclarations.nextTree());

                            }
                            stream_classScopeDeclarations.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 18, enumClassScopeDeclarations_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "enumClassScopeDeclarations"

    public static class enumConstants_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "enumConstants"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:508:1: enumConstants : enumConstant ( COMMA enumConstant )* ;

    public final JavaParser.enumConstants_return enumConstants() throws RecognitionException
    {
        JavaParser.enumConstants_return retval = new JavaParser.enumConstants_return();
        retval.start = input.LT(1);
        int enumConstants_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA60 = null;
        JavaParser.enumConstant_return enumConstant59 = null;

        JavaParser.enumConstant_return enumConstant61 = null;


        CommonTree COMMA60_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 19))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:509:5: ( enumConstant ( COMMA enumConstant )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:509:9: enumConstant ( COMMA enumConstant )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_enumConstant_in_enumConstants5357);
                enumConstant59 = enumConstant();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, enumConstant59.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:509:22: ( COMMA enumConstant )*
                loop20:
                do
                {
                    int alt20 = 2;
                    int LA20_0 = input.LA(1);

                    if ((LA20_0 == COMMA))
                    {
                        int LA20_1 = input.LA(2);

                        if ((LA20_1 == AT || LA20_1 == IDENT))
                        {
                            alt20 = 1;
                        }


                    }


                    switch (alt20)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:509:23: COMMA enumConstant
                        {
                            COMMA60 = (Token) match(input, COMMA, FOLLOW_COMMA_in_enumConstants5360);
                            if (state.failed) return retval;
                            pushFollow(FOLLOW_enumConstant_in_enumConstants5363);
                            enumConstant61 = enumConstant();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, enumConstant61.getTree());

                        }
                        break;

                        default:
                            break loop20;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 19, enumConstants_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "enumConstants"

    public static class enumConstant_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "enumConstant"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:512:1: enumConstant : annotationList IDENT ( arguments )? ( classBody )? ;

    public final JavaParser.enumConstant_return enumConstant() throws RecognitionException
    {
        JavaParser.enumConstant_return retval = new JavaParser.enumConstant_return();
        retval.start = input.LT(1);
        int enumConstant_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT63 = null;
        JavaParser.annotationList_return annotationList62 = null;

        JavaParser.arguments_return arguments64 = null;

        JavaParser.classBody_return classBody65 = null;


        CommonTree IDENT63_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 20))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:513:5: ( annotationList IDENT ( arguments )? ( classBody )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:513:9: annotationList IDENT ( arguments )? ( classBody )?
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_annotationList_in_enumConstant5384);
                annotationList62 = annotationList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, annotationList62.getTree());
                IDENT63 = (Token) match(input, IDENT, FOLLOW_IDENT_in_enumConstant5386);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    IDENT63_tree = (CommonTree) adaptor.create(IDENT63);
                    root_0 = (CommonTree) adaptor.becomeRoot(IDENT63_tree, root_0);
                }
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:513:31: ( arguments )?
                int alt21 = 2;
                int LA21_0 = input.LA(1);

                if ((LA21_0 == LPAREN))
                {
                    alt21 = 1;
                }
                switch (alt21)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arguments
                    {
                        pushFollow(FOLLOW_arguments_in_enumConstant5389);
                        arguments64 = arguments();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, arguments64.getTree());

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:513:42: ( classBody )?
                int alt22 = 2;
                int LA22_0 = input.LA(1);

                if ((LA22_0 == LCURLY))
                {
                    alt22 = 1;
                }
                switch (alt22)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: classBody
                    {
                        pushFollow(FOLLOW_classBody_in_enumConstant5392);
                        classBody65 = classBody();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, classBody65.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 20, enumConstant_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "enumConstant"

    public static class interfaceTypeDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "interfaceTypeDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:516:1: interfaceTypeDeclaration[CommonTree modifiers] : INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody -> ^( INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody ) ;

    public final JavaParser.interfaceTypeDeclaration_return interfaceTypeDeclaration(CommonTree modifiers) throws RecognitionException
    {
        JavaParser.interfaceTypeDeclaration_return retval = new JavaParser.interfaceTypeDeclaration_return();
        retval.start = input.LT(1);
        int interfaceTypeDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        Token INTERFACE66 = null;
        Token IDENT67 = null;
        JavaParser.genericTypeParameterList_return genericTypeParameterList68 = null;

        JavaParser.interfaceExtendsClause_return interfaceExtendsClause69 = null;

        JavaParser.interfaceBody_return interfaceBody70 = null;


        CommonTree INTERFACE66_tree = null;
        CommonTree IDENT67_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_INTERFACE = new RewriteRuleTokenStream(adaptor, "token INTERFACE");
        RewriteRuleSubtreeStream stream_genericTypeParameterList = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeParameterList");
        RewriteRuleSubtreeStream stream_interfaceBody = new RewriteRuleSubtreeStream(adaptor, "rule interfaceBody");
        RewriteRuleSubtreeStream stream_interfaceExtendsClause = new RewriteRuleSubtreeStream(adaptor, "rule interfaceExtendsClause");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 21))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:517:5: ( INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody -> ^( INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:517:9: INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody
            {
                INTERFACE66 = (Token) match(input, INTERFACE, FOLLOW_INTERFACE_in_interfaceTypeDeclaration5413);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_INTERFACE.add(INTERFACE66);

                IDENT67 = (Token) match(input, IDENT, FOLLOW_IDENT_in_interfaceTypeDeclaration5415);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IDENT.add(IDENT67);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:517:25: ( genericTypeParameterList )?
                int alt23 = 2;
                int LA23_0 = input.LA(1);

                if ((LA23_0 == LESS_THAN))
                {
                    alt23 = 1;
                }
                switch (alt23)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                    {
                        pushFollow(FOLLOW_genericTypeParameterList_in_interfaceTypeDeclaration5417);
                        genericTypeParameterList68 = genericTypeParameterList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_genericTypeParameterList.add(genericTypeParameterList68.getTree());

                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:517:51: ( interfaceExtendsClause )?
                int alt24 = 2;
                int LA24_0 = input.LA(1);

                if ((LA24_0 == EXTENDS))
                {
                    alt24 = 1;
                }
                switch (alt24)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: interfaceExtendsClause
                    {
                        pushFollow(FOLLOW_interfaceExtendsClause_in_interfaceTypeDeclaration5420);
                        interfaceExtendsClause69 = interfaceExtendsClause();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_interfaceExtendsClause.add(interfaceExtendsClause69.getTree());

                    }
                    break;

                }

                pushFollow(FOLLOW_interfaceBody_in_interfaceTypeDeclaration5423);
                interfaceBody70 = interfaceBody();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_interfaceBody.add(interfaceBody70.getTree());


                // AST REWRITE
                // elements: INTERFACE, IDENT, genericTypeParameterList, interfaceBody, interfaceExtendsClause
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 518:9: -> ^( INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:518:13: ^( INTERFACE IDENT ( genericTypeParameterList )? ( interfaceExtendsClause )? interfaceBody )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot(stream_INTERFACE.nextNode(), root_1);

                            adaptor.addChild(root_1, modifiers);
                            adaptor.addChild(root_1, stream_IDENT.nextNode());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:518:44: ( genericTypeParameterList )?
                            if (stream_genericTypeParameterList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                            }
                            stream_genericTypeParameterList.reset();
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:518:70: ( interfaceExtendsClause )?
                            if (stream_interfaceExtendsClause.hasNext())
                            {
                                adaptor.addChild(root_1, stream_interfaceExtendsClause.nextTree());

                            }
                            stream_interfaceExtendsClause.reset();
                            adaptor.addChild(root_1, stream_interfaceBody.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 21, interfaceTypeDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "interfaceTypeDeclaration"

    public static class typeList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "typeList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:521:1: typeList : type ( COMMA type )* ;

    public final JavaParser.typeList_return typeList() throws RecognitionException
    {
        JavaParser.typeList_return retval = new JavaParser.typeList_return();
        retval.start = input.LT(1);
        int typeList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA72 = null;
        JavaParser.type_return type71 = null;

        JavaParser.type_return type73 = null;


        CommonTree COMMA72_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 22))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:522:5: ( type ( COMMA type )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:522:9: type ( COMMA type )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_type_in_typeList5469);
                type71 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, type71.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:522:14: ( COMMA type )*
                loop25:
                do
                {
                    int alt25 = 2;
                    int LA25_0 = input.LA(1);

                    if ((LA25_0 == COMMA))
                    {
                        alt25 = 1;
                    }


                    switch (alt25)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:522:15: COMMA type
                        {
                            COMMA72 = (Token) match(input, COMMA, FOLLOW_COMMA_in_typeList5472);
                            if (state.failed) return retval;
                            pushFollow(FOLLOW_type_in_typeList5475);
                            type73 = type();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, type73.getTree());

                        }
                        break;

                        default:
                            break loop25;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 22, typeList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "typeList"

    public static class classBody_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "classBody"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:525:1: classBody : LCURLY ( classScopeDeclarations )* RCURLY -> ^( CLASS_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* ) ;

    public final JavaParser.classBody_return classBody() throws RecognitionException
    {
        JavaParser.classBody_return retval = new JavaParser.classBody_return();
        retval.start = input.LT(1);
        int classBody_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY74 = null;
        Token RCURLY76 = null;
        JavaParser.classScopeDeclarations_return classScopeDeclarations75 = null;


        CommonTree LCURLY74_tree = null;
        CommonTree RCURLY76_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_classScopeDeclarations = new RewriteRuleSubtreeStream(adaptor, "rule classScopeDeclarations");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 23))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:526:5: ( LCURLY ( classScopeDeclarations )* RCURLY -> ^( CLASS_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:526:9: LCURLY ( classScopeDeclarations )* RCURLY
            {
                LCURLY74 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_classBody5496);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY74);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:526:16: ( classScopeDeclarations )*
                loop26:
                do
                {
                    int alt26 = 2;
                    int LA26_0 = input.LA(1);

                    if ((LA26_0 == AT || LA26_0 == LCURLY || LA26_0 == LESS_THAN || LA26_0 == SEMI || LA26_0 == ABSTRACT || LA26_0 == BOOLEAN || LA26_0 == BYTE || (LA26_0 >= CHAR && LA26_0 <= CLASS) || LA26_0 == DOUBLE || LA26_0 == ENUM || LA26_0 == FINAL || LA26_0 == FLOAT || LA26_0 == INTERFACE || (LA26_0 >= INT && LA26_0 <= NATIVE) || (LA26_0 >= PRIVATE && LA26_0 <= PUBLIC) || (LA26_0 >= SHORT && LA26_0 <= STRICTFP) || LA26_0 == SYNCHRONIZED || LA26_0 == TRANSIENT || (LA26_0 >= VOID && LA26_0 <= VOLATILE) || LA26_0 == IDENT))
                    {
                        alt26 = 1;
                    }


                    switch (alt26)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: classScopeDeclarations
                        {
                            pushFollow(FOLLOW_classScopeDeclarations_in_classBody5498);
                            classScopeDeclarations75 = classScopeDeclarations();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_classScopeDeclarations.add(classScopeDeclarations75.getTree());

                        }
                        break;

                        default:
                            break loop26;
                    }
                }
                while (true);

                RCURLY76 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_classBody5501);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY76);


                // AST REWRITE
                // elements: classScopeDeclarations
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 527:9: -> ^( CLASS_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:527:13: ^( CLASS_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( classScopeDeclarations )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CLASS_TOP_LEVEL_SCOPE, LCURLY74, "CLASS_TOP_LEVEL_SCOPE"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:527:71: ( classScopeDeclarations )*
                            while (stream_classScopeDeclarations.hasNext())
                            {
                                adaptor.addChild(root_1, stream_classScopeDeclarations.nextTree());

                            }
                            stream_classScopeDeclarations.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 23, classBody_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "classBody"

    public static class interfaceBody_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "interfaceBody"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:530:1: interfaceBody : LCURLY ( interfaceScopeDeclarations )* RCURLY -> ^( INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( interfaceScopeDeclarations )* ) ;

    public final JavaParser.interfaceBody_return interfaceBody() throws RecognitionException
    {
        JavaParser.interfaceBody_return retval = new JavaParser.interfaceBody_return();
        retval.start = input.LT(1);
        int interfaceBody_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY77 = null;
        Token RCURLY79 = null;
        JavaParser.interfaceScopeDeclarations_return interfaceScopeDeclarations78 = null;


        CommonTree LCURLY77_tree = null;
        CommonTree RCURLY79_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_interfaceScopeDeclarations = new RewriteRuleSubtreeStream(adaptor, "rule interfaceScopeDeclarations");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 24))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:531:5: ( LCURLY ( interfaceScopeDeclarations )* RCURLY -> ^( INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( interfaceScopeDeclarations )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:531:9: LCURLY ( interfaceScopeDeclarations )* RCURLY
            {
                LCURLY77 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_interfaceBody5539);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY77);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:531:16: ( interfaceScopeDeclarations )*
                loop27:
                do
                {
                    int alt27 = 2;
                    int LA27_0 = input.LA(1);

                    if ((LA27_0 == AT || LA27_0 == LESS_THAN || LA27_0 == SEMI || LA27_0 == ABSTRACT || LA27_0 == BOOLEAN || LA27_0 == BYTE || (LA27_0 >= CHAR && LA27_0 <= CLASS) || LA27_0 == DOUBLE || LA27_0 == ENUM || LA27_0 == FINAL || LA27_0 == FLOAT || LA27_0 == INTERFACE || (LA27_0 >= INT && LA27_0 <= NATIVE) || (LA27_0 >= PRIVATE && LA27_0 <= PUBLIC) || (LA27_0 >= SHORT && LA27_0 <= STRICTFP) || LA27_0 == SYNCHRONIZED || LA27_0 == TRANSIENT || (LA27_0 >= VOID && LA27_0 <= VOLATILE) || LA27_0 == IDENT))
                    {
                        alt27 = 1;
                    }


                    switch (alt27)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: interfaceScopeDeclarations
                        {
                            pushFollow(FOLLOW_interfaceScopeDeclarations_in_interfaceBody5541);
                            interfaceScopeDeclarations78 = interfaceScopeDeclarations();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_interfaceScopeDeclarations.add(interfaceScopeDeclarations78.getTree());

                        }
                        break;

                        default:
                            break loop27;
                    }
                }
                while (true);

                RCURLY79 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_interfaceBody5544);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY79);


                // AST REWRITE
                // elements: interfaceScopeDeclarations
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 532:9: -> ^( INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( interfaceScopeDeclarations )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:532:13: ^( INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( interfaceScopeDeclarations )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(INTERFACE_TOP_LEVEL_SCOPE, LCURLY77, "CLASS_TOP_LEVEL_SCOPE"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:532:75: ( interfaceScopeDeclarations )*
                            while (stream_interfaceScopeDeclarations.hasNext())
                            {
                                adaptor.addChild(root_1, stream_interfaceScopeDeclarations.nextTree());

                            }
                            stream_interfaceScopeDeclarations.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 24, interfaceBody_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "interfaceBody"

    public static class classScopeDeclarations_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "classScopeDeclarations"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:535:1: classScopeDeclarations : ( block -> ^( CLASS_INSTANCE_INITIALIZER block ) | STATIC block -> ^( CLASS_STATIC_INITIALIZER[$STATIC, \"CLASS_STATIC_INITIALIZER\"] block ) | modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) ) | type classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) ) | typeDeclaration | SEMI );

    public final JavaParser.classScopeDeclarations_return classScopeDeclarations() throws RecognitionException
    {
        JavaParser.classScopeDeclarations_return retval = new JavaParser.classScopeDeclarations_return();
        retval.start = input.LT(1);
        int classScopeDeclarations_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ident = null;
        Token STATIC81 = null;
        Token IDENT86 = null;
        Token SEMI91 = null;
        Token VOID92 = null;
        Token IDENT93 = null;
        Token SEMI97 = null;
        Token SEMI103 = null;
        Token SEMI105 = null;
        JavaParser.block_return block80 = null;

        JavaParser.block_return block82 = null;

        JavaParser.modifierList_return modifierList83 = null;

        JavaParser.genericTypeParameterList_return genericTypeParameterList84 = null;

        JavaParser.type_return type85 = null;

        JavaParser.formalParameterList_return formalParameterList87 = null;

        JavaParser.arrayDeclaratorList_return arrayDeclaratorList88 = null;

        JavaParser.throwsClause_return throwsClause89 = null;

        JavaParser.block_return block90 = null;

        JavaParser.formalParameterList_return formalParameterList94 = null;

        JavaParser.throwsClause_return throwsClause95 = null;

        JavaParser.block_return block96 = null;

        JavaParser.formalParameterList_return formalParameterList98 = null;

        JavaParser.throwsClause_return throwsClause99 = null;

        JavaParser.block_return block100 = null;

        JavaParser.type_return type101 = null;

        JavaParser.classFieldDeclaratorList_return classFieldDeclaratorList102 = null;

        JavaParser.typeDeclaration_return typeDeclaration104 = null;


        CommonTree ident_tree = null;
        CommonTree STATIC81_tree = null;
        CommonTree IDENT86_tree = null;
        CommonTree SEMI91_tree = null;
        CommonTree VOID92_tree = null;
        CommonTree IDENT93_tree = null;
        CommonTree SEMI97_tree = null;
        CommonTree SEMI103_tree = null;
        CommonTree SEMI105_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_VOID = new RewriteRuleTokenStream(adaptor, "token VOID");
        RewriteRuleTokenStream stream_SEMI = new RewriteRuleTokenStream(adaptor, "token SEMI");
        RewriteRuleTokenStream stream_STATIC = new RewriteRuleTokenStream(adaptor, "token STATIC");
        RewriteRuleSubtreeStream stream_arrayDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclaratorList");
        RewriteRuleSubtreeStream stream_throwsClause = new RewriteRuleSubtreeStream(adaptor, "rule throwsClause");
        RewriteRuleSubtreeStream stream_modifierList = new RewriteRuleSubtreeStream(adaptor, "rule modifierList");
        RewriteRuleSubtreeStream stream_genericTypeParameterList = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeParameterList");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor, "rule block");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        RewriteRuleSubtreeStream stream_classFieldDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule classFieldDeclaratorList");
        RewriteRuleSubtreeStream stream_formalParameterList = new RewriteRuleSubtreeStream(adaptor, "rule formalParameterList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 25))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:536:5: ( block -> ^( CLASS_INSTANCE_INITIALIZER block ) | STATIC block -> ^( CLASS_STATIC_INITIALIZER[$STATIC, \"CLASS_STATIC_INITIALIZER\"] block ) | modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) ) | type classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) ) | typeDeclaration | SEMI )
            int alt37 = 5;
            alt37 = dfa37.predict(input);
            switch (alt37)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:536:9: block
                {
                    pushFollow(FOLLOW_block_in_classScopeDeclarations5582);
                    block80 = block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_block.add(block80.getTree());


                    // AST REWRITE
                    // elements: block
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 536:25: -> ^( CLASS_INSTANCE_INITIALIZER block )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:536:29: ^( CLASS_INSTANCE_INITIALIZER block )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CLASS_INSTANCE_INITIALIZER, "CLASS_INSTANCE_INITIALIZER"), root_1);

                                adaptor.addChild(root_1, stream_block.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:537:9: STATIC block
                {
                    STATIC81 = (Token) match(input, STATIC, FOLLOW_STATIC_in_classScopeDeclarations5611);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_STATIC.add(STATIC81);

                    pushFollow(FOLLOW_block_in_classScopeDeclarations5613);
                    block82 = block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_block.add(block82.getTree());


                    // AST REWRITE
                    // elements: block
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 537:25: -> ^( CLASS_STATIC_INITIALIZER[$STATIC, \"CLASS_STATIC_INITIALIZER\"] block )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:537:29: ^( CLASS_STATIC_INITIALIZER[$STATIC, \"CLASS_STATIC_INITIALIZER\"] block )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CLASS_STATIC_INITIALIZER, STATIC81, "CLASS_STATIC_INITIALIZER"), root_1);

                                adaptor.addChild(root_1, stream_block.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:538:9: modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) ) | type classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) )
                {
                    pushFollow(FOLLOW_modifierList_in_classScopeDeclarations5636);
                    modifierList83 = modifierList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_modifierList.add(modifierList83.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:9: ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) ) | type classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) )
                    int alt36 = 2;
                    switch (input.LA(1))
                    {
                        case LESS_THAN:
                        case VOID:
                        {
                            alt36 = 1;
                        }
                        break;
                        case BOOLEAN:
                        case BYTE:
                        case CHAR:
                        case DOUBLE:
                        case FLOAT:
                        case INT:
                        case LONG:
                        case SHORT:
                        {
                            int LA36_2 = input.LA(2);

                            if ((synpred43_Java()))
                            {
                                alt36 = 1;
                            }
                            else if ((true))
                            {
                                alt36 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 36, 2, input);

                                throw nvae;
                            }
                        }
                        break;
                        case IDENT:
                        {
                            int LA36_3 = input.LA(2);

                            if ((synpred43_Java()))
                            {
                                alt36 = 1;
                            }
                            else if ((true))
                            {
                                alt36 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 36, 3, input);

                                throw nvae;
                            }
                        }
                        break;
                        default:
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 36, 0, input);

                            throw nvae;
                    }

                    switch (alt36)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( genericTypeParameterList )?
                            int alt28 = 2;
                            int LA28_0 = input.LA(1);

                            if ((LA28_0 == LESS_THAN))
                            {
                                alt28 = 1;
                            }
                            switch (alt28)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                                {
                                    pushFollow(FOLLOW_genericTypeParameterList_in_classScopeDeclarations5650);
                                    genericTypeParameterList84 = genericTypeParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_genericTypeParameterList.add(genericTypeParameterList84.getTree());

                                }
                                break;

                            }

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:13: ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) )
                            int alt35 = 3;
                            switch (input.LA(1))
                            {
                                case BOOLEAN:
                                case BYTE:
                                case CHAR:
                                case DOUBLE:
                                case FLOAT:
                                case INT:
                                case LONG:
                                case SHORT:
                                {
                                    alt35 = 1;
                                }
                                break;
                                case IDENT:
                                {
                                    int LA35_2 = input.LA(2);

                                    if ((LA35_2 == LPAREN))
                                    {
                                        alt35 = 3;
                                    }
                                    else if ((LA35_2 == DOT || LA35_2 == LBRACK || LA35_2 == LESS_THAN || LA35_2 == IDENT))
                                    {
                                        alt35 = 1;
                                    }
                                    else
                                    {
                                        if (state.backtracking > 0)
                                        {
                                            state.failed = true;
                                            return retval;
                                        }
                                        NoViableAltException nvae =
                                                new NoViableAltException("", 35, 2, input);

                                        throw nvae;
                                    }
                                }
                                break;
                                case VOID:
                                {
                                    alt35 = 2;
                                }
                                break;
                                default:
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    NoViableAltException nvae =
                                            new NoViableAltException("", 35, 0, input);

                                    throw nvae;
                            }

                            switch (alt35)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:17: type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI )
                                {
                                    pushFollow(FOLLOW_type_in_classScopeDeclarations5669);
                                    type85 = type();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_type.add(type85.getTree());
                                    IDENT86 = (Token) match(input, IDENT, FOLLOW_IDENT_in_classScopeDeclarations5671);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_IDENT.add(IDENT86);

                                    pushFollow(FOLLOW_formalParameterList_in_classScopeDeclarations5673);
                                    formalParameterList87 = formalParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_formalParameterList.add(formalParameterList87.getTree());
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:48: ( arrayDeclaratorList )?
                                    int alt29 = 2;
                                    int LA29_0 = input.LA(1);

                                    if ((LA29_0 == LBRACK))
                                    {
                                        alt29 = 1;
                                    }
                                    switch (alt29)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                                        {
                                            pushFollow(FOLLOW_arrayDeclaratorList_in_classScopeDeclarations5675);
                                            arrayDeclaratorList88 = arrayDeclaratorList();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_arrayDeclaratorList.add(arrayDeclaratorList88.getTree());

                                        }
                                        break;

                                    }

                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:69: ( throwsClause )?
                                    int alt30 = 2;
                                    int LA30_0 = input.LA(1);

                                    if ((LA30_0 == THROWS))
                                    {
                                        alt30 = 1;
                                    }
                                    switch (alt30)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                        {
                                            pushFollow(FOLLOW_throwsClause_in_classScopeDeclarations5678);
                                            throwsClause89 = throwsClause();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_throwsClause.add(throwsClause89.getTree());

                                        }
                                        break;

                                    }

                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:83: ( block | SEMI )
                                    int alt31 = 2;
                                    int LA31_0 = input.LA(1);

                                    if ((LA31_0 == LCURLY))
                                    {
                                        alt31 = 1;
                                    }
                                    else if ((LA31_0 == SEMI))
                                    {
                                        alt31 = 2;
                                    }
                                    else
                                    {
                                        if (state.backtracking > 0)
                                        {
                                            state.failed = true;
                                            return retval;
                                        }
                                        NoViableAltException nvae =
                                                new NoViableAltException("", 31, 0, input);

                                        throw nvae;
                                    }
                                    switch (alt31)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:84: block
                                        {
                                            pushFollow(FOLLOW_block_in_classScopeDeclarations5682);
                                            block90 = block();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0) stream_block.add(block90.getTree());

                                        }
                                        break;
                                        case 2:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:92: SEMI
                                        {
                                            SEMI91 = (Token) match(input, SEMI, FOLLOW_SEMI_in_classScopeDeclarations5686);
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0) stream_SEMI.add(SEMI91);


                                        }
                                        break;

                                    }


                                    // AST REWRITE
                                    // elements: block, type, arrayDeclaratorList, throwsClause, IDENT, genericTypeParameterList, formalParameterList, modifierList
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 541:17: -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:541:21: ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FUNCTION_METHOD_DECL, "FUNCTION_METHOD_DECL"), root_1);

                                                adaptor.addChild(root_1, stream_modifierList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:541:57: ( genericTypeParameterList )?
                                                if (stream_genericTypeParameterList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                                                }
                                                stream_genericTypeParameterList.reset();
                                                adaptor.addChild(root_1, stream_type.nextTree());
                                                adaptor.addChild(root_1, stream_IDENT.nextNode());
                                                adaptor.addChild(root_1, stream_formalParameterList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:541:114: ( arrayDeclaratorList )?
                                                if (stream_arrayDeclaratorList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_arrayDeclaratorList.nextTree());

                                                }
                                                stream_arrayDeclaratorList.reset();
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:541:135: ( throwsClause )?
                                                if (stream_throwsClause.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_throwsClause.nextTree());

                                                }
                                                stream_throwsClause.reset();
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:541:149: ( block )?
                                                if (stream_block.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_block.nextTree());

                                                }
                                                stream_block.reset();

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:17: VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI )
                                {
                                    VOID92 = (Token) match(input, VOID, FOLLOW_VOID_in_classScopeDeclarations5748);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_VOID.add(VOID92);

                                    IDENT93 = (Token) match(input, IDENT, FOLLOW_IDENT_in_classScopeDeclarations5750);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_IDENT.add(IDENT93);

                                    pushFollow(FOLLOW_formalParameterList_in_classScopeDeclarations5752);
                                    formalParameterList94 = formalParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_formalParameterList.add(formalParameterList94.getTree());
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:48: ( throwsClause )?
                                    int alt32 = 2;
                                    int LA32_0 = input.LA(1);

                                    if ((LA32_0 == THROWS))
                                    {
                                        alt32 = 1;
                                    }
                                    switch (alt32)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                        {
                                            pushFollow(FOLLOW_throwsClause_in_classScopeDeclarations5754);
                                            throwsClause95 = throwsClause();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_throwsClause.add(throwsClause95.getTree());

                                        }
                                        break;

                                    }

                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:62: ( block | SEMI )
                                    int alt33 = 2;
                                    int LA33_0 = input.LA(1);

                                    if ((LA33_0 == LCURLY))
                                    {
                                        alt33 = 1;
                                    }
                                    else if ((LA33_0 == SEMI))
                                    {
                                        alt33 = 2;
                                    }
                                    else
                                    {
                                        if (state.backtracking > 0)
                                        {
                                            state.failed = true;
                                            return retval;
                                        }
                                        NoViableAltException nvae =
                                                new NoViableAltException("", 33, 0, input);

                                        throw nvae;
                                    }
                                    switch (alt33)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:63: block
                                        {
                                            pushFollow(FOLLOW_block_in_classScopeDeclarations5758);
                                            block96 = block();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0) stream_block.add(block96.getTree());

                                        }
                                        break;
                                        case 2:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:71: SEMI
                                        {
                                            SEMI97 = (Token) match(input, SEMI, FOLLOW_SEMI_in_classScopeDeclarations5762);
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0) stream_SEMI.add(SEMI97);


                                        }
                                        break;

                                    }


                                    // AST REWRITE
                                    // elements: modifierList, throwsClause, genericTypeParameterList, IDENT, block, formalParameterList
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 543:17: -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:543:21: ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VOID_METHOD_DECL, "VOID_METHOD_DECL"), root_1);

                                                adaptor.addChild(root_1, stream_modifierList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:543:53: ( genericTypeParameterList )?
                                                if (stream_genericTypeParameterList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                                                }
                                                stream_genericTypeParameterList.reset();
                                                adaptor.addChild(root_1, stream_IDENT.nextNode());
                                                adaptor.addChild(root_1, stream_formalParameterList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:543:105: ( throwsClause )?
                                                if (stream_throwsClause.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_throwsClause.nextTree());

                                                }
                                                stream_throwsClause.reset();
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:543:119: ( block )?
                                                if (stream_block.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_block.nextTree());

                                                }
                                                stream_block.reset();

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;
                                case 3:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:544:17: ident= IDENT formalParameterList ( throwsClause )? block
                                {
                                    ident = (Token) match(input, IDENT, FOLLOW_IDENT_in_classScopeDeclarations5821);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_IDENT.add(ident);

                                    pushFollow(FOLLOW_formalParameterList_in_classScopeDeclarations5823);
                                    formalParameterList98 = formalParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_formalParameterList.add(formalParameterList98.getTree());
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:544:49: ( throwsClause )?
                                    int alt34 = 2;
                                    int LA34_0 = input.LA(1);

                                    if ((LA34_0 == THROWS))
                                    {
                                        alt34 = 1;
                                    }
                                    switch (alt34)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                        {
                                            pushFollow(FOLLOW_throwsClause_in_classScopeDeclarations5825);
                                            throwsClause99 = throwsClause();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_throwsClause.add(throwsClause99.getTree());

                                        }
                                        break;

                                    }

                                    pushFollow(FOLLOW_block_in_classScopeDeclarations5828);
                                    block100 = block();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_block.add(block100.getTree());


                                    // AST REWRITE
                                    // elements: genericTypeParameterList, block, formalParameterList, modifierList, throwsClause
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 545:17: -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:545:21: ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CONSTRUCTOR_DECL, ident, "CONSTRUCTOR_DECL"), root_1);

                                                adaptor.addChild(root_1, stream_modifierList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:545:81: ( genericTypeParameterList )?
                                                if (stream_genericTypeParameterList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                                                }
                                                stream_genericTypeParameterList.reset();
                                                adaptor.addChild(root_1, stream_formalParameterList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:545:127: ( throwsClause )?
                                                if (stream_throwsClause.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_throwsClause.nextTree());

                                                }
                                                stream_throwsClause.reset();
                                                adaptor.addChild(root_1, stream_block.nextTree());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;

                            }


                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:547:13: type classFieldDeclaratorList SEMI
                        {
                            pushFollow(FOLLOW_type_in_classScopeDeclarations5892);
                            type101 = type();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_type.add(type101.getTree());
                            pushFollow(FOLLOW_classFieldDeclaratorList_in_classScopeDeclarations5894);
                            classFieldDeclaratorList102 = classFieldDeclaratorList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_classFieldDeclaratorList.add(classFieldDeclaratorList102.getTree());
                            SEMI103 = (Token) match(input, SEMI, FOLLOW_SEMI_in_classScopeDeclarations5896);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI103);


                            // AST REWRITE
                            // elements: classFieldDeclaratorList, type, modifierList
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 548:13: -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:548:17: ^( VAR_DECLARATION modifierList type classFieldDeclaratorList )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATION, "VAR_DECLARATION"), root_1);

                                        adaptor.addChild(root_1, stream_modifierList.nextTree());
                                        adaptor.addChild(root_1, stream_type.nextTree());
                                        adaptor.addChild(root_1, stream_classFieldDeclaratorList.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:550:9: typeDeclaration
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_typeDeclaration_in_classScopeDeclarations5941);
                    typeDeclaration104 = typeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, typeDeclaration104.getTree());

                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:551:9: SEMI
                {
                    root_0 = (CommonTree) adaptor.nil();

                    SEMI105 = (Token) match(input, SEMI, FOLLOW_SEMI_in_classScopeDeclarations5951);
                    if (state.failed) return retval;

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 25, classScopeDeclarations_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "classScopeDeclarations"

    public static class interfaceScopeDeclarations_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "interfaceScopeDeclarations"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:554:1: interfaceScopeDeclarations : ( modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) ) | type interfaceFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList ) ) | typeDeclaration | SEMI );

    public final JavaParser.interfaceScopeDeclarations_return interfaceScopeDeclarations() throws RecognitionException
    {
        JavaParser.interfaceScopeDeclarations_return retval = new JavaParser.interfaceScopeDeclarations_return();
        retval.start = input.LT(1);
        int interfaceScopeDeclarations_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT109 = null;
        Token SEMI113 = null;
        Token VOID114 = null;
        Token IDENT115 = null;
        Token SEMI118 = null;
        Token SEMI121 = null;
        Token SEMI123 = null;
        JavaParser.modifierList_return modifierList106 = null;

        JavaParser.genericTypeParameterList_return genericTypeParameterList107 = null;

        JavaParser.type_return type108 = null;

        JavaParser.formalParameterList_return formalParameterList110 = null;

        JavaParser.arrayDeclaratorList_return arrayDeclaratorList111 = null;

        JavaParser.throwsClause_return throwsClause112 = null;

        JavaParser.formalParameterList_return formalParameterList116 = null;

        JavaParser.throwsClause_return throwsClause117 = null;

        JavaParser.type_return type119 = null;

        JavaParser.interfaceFieldDeclaratorList_return interfaceFieldDeclaratorList120 = null;

        JavaParser.typeDeclaration_return typeDeclaration122 = null;


        CommonTree IDENT109_tree = null;
        CommonTree SEMI113_tree = null;
        CommonTree VOID114_tree = null;
        CommonTree IDENT115_tree = null;
        CommonTree SEMI118_tree = null;
        CommonTree SEMI121_tree = null;
        CommonTree SEMI123_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_VOID = new RewriteRuleTokenStream(adaptor, "token VOID");
        RewriteRuleTokenStream stream_SEMI = new RewriteRuleTokenStream(adaptor, "token SEMI");
        RewriteRuleSubtreeStream stream_arrayDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclaratorList");
        RewriteRuleSubtreeStream stream_throwsClause = new RewriteRuleSubtreeStream(adaptor, "rule throwsClause");
        RewriteRuleSubtreeStream stream_modifierList = new RewriteRuleSubtreeStream(adaptor, "rule modifierList");
        RewriteRuleSubtreeStream stream_genericTypeParameterList = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeParameterList");
        RewriteRuleSubtreeStream stream_interfaceFieldDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule interfaceFieldDeclaratorList");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        RewriteRuleSubtreeStream stream_formalParameterList = new RewriteRuleSubtreeStream(adaptor, "rule formalParameterList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 26))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:555:5: ( modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) ) | type interfaceFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList ) ) | typeDeclaration | SEMI )
            int alt44 = 3;
            alt44 = dfa44.predict(input);
            switch (alt44)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:555:9: modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) ) | type interfaceFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList ) )
                {
                    pushFollow(FOLLOW_modifierList_in_interfaceScopeDeclarations5971);
                    modifierList106 = modifierList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_modifierList.add(modifierList106.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:9: ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) ) | type interfaceFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList ) )
                    int alt43 = 2;
                    switch (input.LA(1))
                    {
                        case LESS_THAN:
                        case VOID:
                        {
                            alt43 = 1;
                        }
                        break;
                        case BOOLEAN:
                        case BYTE:
                        case CHAR:
                        case DOUBLE:
                        case FLOAT:
                        case INT:
                        case LONG:
                        case SHORT:
                        {
                            int LA43_2 = input.LA(2);

                            if ((synpred51_Java()))
                            {
                                alt43 = 1;
                            }
                            else if ((true))
                            {
                                alt43 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 43, 2, input);

                                throw nvae;
                            }
                        }
                        break;
                        case IDENT:
                        {
                            int LA43_3 = input.LA(2);

                            if ((synpred51_Java()))
                            {
                                alt43 = 1;
                            }
                            else if ((true))
                            {
                                alt43 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 43, 3, input);

                                throw nvae;
                            }
                        }
                        break;
                        default:
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 43, 0, input);

                            throw nvae;
                    }

                    switch (alt43)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( genericTypeParameterList )?
                            int alt38 = 2;
                            int LA38_0 = input.LA(1);

                            if ((LA38_0 == LESS_THAN))
                            {
                                alt38 = 1;
                            }
                            switch (alt38)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                                {
                                    pushFollow(FOLLOW_genericTypeParameterList_in_interfaceScopeDeclarations5985);
                                    genericTypeParameterList107 = genericTypeParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_genericTypeParameterList.add(genericTypeParameterList107.getTree());

                                }
                                break;

                            }

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:13: ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) )
                            int alt42 = 2;
                            int LA42_0 = input.LA(1);

                            if ((LA42_0 == BOOLEAN || LA42_0 == BYTE || LA42_0 == CHAR || LA42_0 == DOUBLE || LA42_0 == FLOAT || (LA42_0 >= INT && LA42_0 <= LONG) || LA42_0 == SHORT || LA42_0 == IDENT))
                            {
                                alt42 = 1;
                            }
                            else if ((LA42_0 == VOID))
                            {
                                alt42 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 42, 0, input);

                                throw nvae;
                            }
                            switch (alt42)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:17: type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI
                                {
                                    pushFollow(FOLLOW_type_in_interfaceScopeDeclarations6004);
                                    type108 = type();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_type.add(type108.getTree());
                                    IDENT109 = (Token) match(input, IDENT, FOLLOW_IDENT_in_interfaceScopeDeclarations6006);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_IDENT.add(IDENT109);

                                    pushFollow(FOLLOW_formalParameterList_in_interfaceScopeDeclarations6008);
                                    formalParameterList110 = formalParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_formalParameterList.add(formalParameterList110.getTree());
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:48: ( arrayDeclaratorList )?
                                    int alt39 = 2;
                                    int LA39_0 = input.LA(1);

                                    if ((LA39_0 == LBRACK))
                                    {
                                        alt39 = 1;
                                    }
                                    switch (alt39)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                                        {
                                            pushFollow(FOLLOW_arrayDeclaratorList_in_interfaceScopeDeclarations6010);
                                            arrayDeclaratorList111 = arrayDeclaratorList();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_arrayDeclaratorList.add(arrayDeclaratorList111.getTree());

                                        }
                                        break;

                                    }

                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:69: ( throwsClause )?
                                    int alt40 = 2;
                                    int LA40_0 = input.LA(1);

                                    if ((LA40_0 == THROWS))
                                    {
                                        alt40 = 1;
                                    }
                                    switch (alt40)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                        {
                                            pushFollow(FOLLOW_throwsClause_in_interfaceScopeDeclarations6013);
                                            throwsClause112 = throwsClause();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_throwsClause.add(throwsClause112.getTree());

                                        }
                                        break;

                                    }

                                    SEMI113 = (Token) match(input, SEMI, FOLLOW_SEMI_in_interfaceScopeDeclarations6016);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_SEMI.add(SEMI113);


                                    // AST REWRITE
                                    // elements: type, throwsClause, modifierList, formalParameterList, IDENT, arrayDeclaratorList, genericTypeParameterList
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 558:17: -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:558:21: ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FUNCTION_METHOD_DECL, "FUNCTION_METHOD_DECL"), root_1);

                                                adaptor.addChild(root_1, stream_modifierList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:558:57: ( genericTypeParameterList )?
                                                if (stream_genericTypeParameterList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                                                }
                                                stream_genericTypeParameterList.reset();
                                                adaptor.addChild(root_1, stream_type.nextTree());
                                                adaptor.addChild(root_1, stream_IDENT.nextNode());
                                                adaptor.addChild(root_1, stream_formalParameterList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:558:114: ( arrayDeclaratorList )?
                                                if (stream_arrayDeclaratorList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_arrayDeclaratorList.nextTree());

                                                }
                                                stream_arrayDeclaratorList.reset();
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:558:135: ( throwsClause )?
                                                if (stream_throwsClause.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_throwsClause.nextTree());

                                                }
                                                stream_throwsClause.reset();

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:559:17: VOID IDENT formalParameterList ( throwsClause )? SEMI
                                {
                                    VOID114 = (Token) match(input, VOID, FOLLOW_VOID_in_interfaceScopeDeclarations6074);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_VOID.add(VOID114);

                                    IDENT115 = (Token) match(input, IDENT, FOLLOW_IDENT_in_interfaceScopeDeclarations6076);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_IDENT.add(IDENT115);

                                    pushFollow(FOLLOW_formalParameterList_in_interfaceScopeDeclarations6078);
                                    formalParameterList116 = formalParameterList();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_formalParameterList.add(formalParameterList116.getTree());
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:559:48: ( throwsClause )?
                                    int alt41 = 2;
                                    int LA41_0 = input.LA(1);

                                    if ((LA41_0 == THROWS))
                                    {
                                        alt41 = 1;
                                    }
                                    switch (alt41)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                        {
                                            pushFollow(FOLLOW_throwsClause_in_interfaceScopeDeclarations6080);
                                            throwsClause117 = throwsClause();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0)
                                                stream_throwsClause.add(throwsClause117.getTree());

                                        }
                                        break;

                                    }

                                    SEMI118 = (Token) match(input, SEMI, FOLLOW_SEMI_in_interfaceScopeDeclarations6083);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_SEMI.add(SEMI118);


                                    // AST REWRITE
                                    // elements: formalParameterList, IDENT, throwsClause, genericTypeParameterList, modifierList
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 560:17: -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:560:21: ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VOID_METHOD_DECL, "VOID_METHOD_DECL"), root_1);

                                                adaptor.addChild(root_1, stream_modifierList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:560:53: ( genericTypeParameterList )?
                                                if (stream_genericTypeParameterList.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_genericTypeParameterList.nextTree());

                                                }
                                                stream_genericTypeParameterList.reset();
                                                adaptor.addChild(root_1, stream_IDENT.nextNode());
                                                adaptor.addChild(root_1, stream_formalParameterList.nextTree());
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:560:105: ( throwsClause )?
                                                if (stream_throwsClause.hasNext())
                                                {
                                                    adaptor.addChild(root_1, stream_throwsClause.nextTree());

                                                }
                                                stream_throwsClause.reset();

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;

                            }


                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:562:13: type interfaceFieldDeclaratorList SEMI
                        {
                            pushFollow(FOLLOW_type_in_interfaceScopeDeclarations6146);
                            type119 = type();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_type.add(type119.getTree());
                            pushFollow(FOLLOW_interfaceFieldDeclaratorList_in_interfaceScopeDeclarations6148);
                            interfaceFieldDeclaratorList120 = interfaceFieldDeclaratorList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_interfaceFieldDeclaratorList.add(interfaceFieldDeclaratorList120.getTree());
                            SEMI121 = (Token) match(input, SEMI, FOLLOW_SEMI_in_interfaceScopeDeclarations6150);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI121);


                            // AST REWRITE
                            // elements: interfaceFieldDeclaratorList, type, modifierList
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 563:13: -> ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:563:17: ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATION, "VAR_DECLARATION"), root_1);

                                        adaptor.addChild(root_1, stream_modifierList.nextTree());
                                        adaptor.addChild(root_1, stream_type.nextTree());
                                        adaptor.addChild(root_1, stream_interfaceFieldDeclaratorList.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:565:9: typeDeclaration
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_typeDeclaration_in_interfaceScopeDeclarations6195);
                    typeDeclaration122 = typeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, typeDeclaration122.getTree());

                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:566:9: SEMI
                {
                    root_0 = (CommonTree) adaptor.nil();

                    SEMI123 = (Token) match(input, SEMI, FOLLOW_SEMI_in_interfaceScopeDeclarations6205);
                    if (state.failed) return retval;

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 26, interfaceScopeDeclarations_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "interfaceScopeDeclarations"

    public static class classFieldDeclaratorList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "classFieldDeclaratorList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:569:1: classFieldDeclaratorList : classFieldDeclarator ( COMMA classFieldDeclarator )* -> ^( VAR_DECLARATOR_LIST ( classFieldDeclarator )+ ) ;

    public final JavaParser.classFieldDeclaratorList_return classFieldDeclaratorList() throws RecognitionException
    {
        JavaParser.classFieldDeclaratorList_return retval = new JavaParser.classFieldDeclaratorList_return();
        retval.start = input.LT(1);
        int classFieldDeclaratorList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA125 = null;
        JavaParser.classFieldDeclarator_return classFieldDeclarator124 = null;

        JavaParser.classFieldDeclarator_return classFieldDeclarator126 = null;


        CommonTree COMMA125_tree = null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleSubtreeStream stream_classFieldDeclarator = new RewriteRuleSubtreeStream(adaptor, "rule classFieldDeclarator");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 27))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:570:5: ( classFieldDeclarator ( COMMA classFieldDeclarator )* -> ^( VAR_DECLARATOR_LIST ( classFieldDeclarator )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:570:9: classFieldDeclarator ( COMMA classFieldDeclarator )*
            {
                pushFollow(FOLLOW_classFieldDeclarator_in_classFieldDeclaratorList6225);
                classFieldDeclarator124 = classFieldDeclarator();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_classFieldDeclarator.add(classFieldDeclarator124.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:570:30: ( COMMA classFieldDeclarator )*
                loop45:
                do
                {
                    int alt45 = 2;
                    int LA45_0 = input.LA(1);

                    if ((LA45_0 == COMMA))
                    {
                        alt45 = 1;
                    }


                    switch (alt45)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:570:31: COMMA classFieldDeclarator
                        {
                            COMMA125 = (Token) match(input, COMMA, FOLLOW_COMMA_in_classFieldDeclaratorList6228);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COMMA.add(COMMA125);

                            pushFollow(FOLLOW_classFieldDeclarator_in_classFieldDeclaratorList6230);
                            classFieldDeclarator126 = classFieldDeclarator();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_classFieldDeclarator.add(classFieldDeclarator126.getTree());

                        }
                        break;

                        default:
                            break loop45;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: classFieldDeclarator
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 571:9: -> ^( VAR_DECLARATOR_LIST ( classFieldDeclarator )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:571:13: ^( VAR_DECLARATOR_LIST ( classFieldDeclarator )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATOR_LIST, "VAR_DECLARATOR_LIST"), root_1);

                            if (!(stream_classFieldDeclarator.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_classFieldDeclarator.hasNext())
                            {
                                adaptor.addChild(root_1, stream_classFieldDeclarator.nextTree());

                            }
                            stream_classFieldDeclarator.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 27, classFieldDeclaratorList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "classFieldDeclaratorList"

    public static class classFieldDeclarator_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "classFieldDeclarator"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:574:1: classFieldDeclarator : variableDeclaratorId ( ASSIGN variableInitializer )? -> ^( VAR_DECLARATOR variableDeclaratorId ( variableInitializer )? ) ;

    public final JavaParser.classFieldDeclarator_return classFieldDeclarator() throws RecognitionException
    {
        JavaParser.classFieldDeclarator_return retval = new JavaParser.classFieldDeclarator_return();
        retval.start = input.LT(1);
        int classFieldDeclarator_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ASSIGN128 = null;
        JavaParser.variableDeclaratorId_return variableDeclaratorId127 = null;

        JavaParser.variableInitializer_return variableInitializer129 = null;


        CommonTree ASSIGN128_tree = null;
        RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor, "token ASSIGN");
        RewriteRuleSubtreeStream stream_variableDeclaratorId = new RewriteRuleSubtreeStream(adaptor, "rule variableDeclaratorId");
        RewriteRuleSubtreeStream stream_variableInitializer = new RewriteRuleSubtreeStream(adaptor, "rule variableInitializer");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 28))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:575:5: ( variableDeclaratorId ( ASSIGN variableInitializer )? -> ^( VAR_DECLARATOR variableDeclaratorId ( variableInitializer )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:575:9: variableDeclaratorId ( ASSIGN variableInitializer )?
            {
                pushFollow(FOLLOW_variableDeclaratorId_in_classFieldDeclarator6269);
                variableDeclaratorId127 = variableDeclaratorId();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_variableDeclaratorId.add(variableDeclaratorId127.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:575:30: ( ASSIGN variableInitializer )?
                int alt46 = 2;
                int LA46_0 = input.LA(1);

                if ((LA46_0 == ASSIGN))
                {
                    alt46 = 1;
                }
                switch (alt46)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:575:31: ASSIGN variableInitializer
                    {
                        ASSIGN128 = (Token) match(input, ASSIGN, FOLLOW_ASSIGN_in_classFieldDeclarator6272);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_ASSIGN.add(ASSIGN128);

                        pushFollow(FOLLOW_variableInitializer_in_classFieldDeclarator6274);
                        variableInitializer129 = variableInitializer();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_variableInitializer.add(variableInitializer129.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: variableInitializer, variableDeclaratorId
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 576:9: -> ^( VAR_DECLARATOR variableDeclaratorId ( variableInitializer )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:576:13: ^( VAR_DECLARATOR variableDeclaratorId ( variableInitializer )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATOR, "VAR_DECLARATOR"), root_1);

                            adaptor.addChild(root_1, stream_variableDeclaratorId.nextTree());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:576:51: ( variableInitializer )?
                            if (stream_variableInitializer.hasNext())
                            {
                                adaptor.addChild(root_1, stream_variableInitializer.nextTree());

                            }
                            stream_variableInitializer.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 28, classFieldDeclarator_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "classFieldDeclarator"

    public static class interfaceFieldDeclaratorList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "interfaceFieldDeclaratorList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:579:1: interfaceFieldDeclaratorList : interfaceFieldDeclarator ( COMMA interfaceFieldDeclarator )* -> ^( VAR_DECLARATOR_LIST ( interfaceFieldDeclarator )+ ) ;

    public final JavaParser.interfaceFieldDeclaratorList_return interfaceFieldDeclaratorList() throws RecognitionException
    {
        JavaParser.interfaceFieldDeclaratorList_return retval = new JavaParser.interfaceFieldDeclaratorList_return();
        retval.start = input.LT(1);
        int interfaceFieldDeclaratorList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA131 = null;
        JavaParser.interfaceFieldDeclarator_return interfaceFieldDeclarator130 = null;

        JavaParser.interfaceFieldDeclarator_return interfaceFieldDeclarator132 = null;


        CommonTree COMMA131_tree = null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleSubtreeStream stream_interfaceFieldDeclarator = new RewriteRuleSubtreeStream(adaptor, "rule interfaceFieldDeclarator");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 29))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:580:5: ( interfaceFieldDeclarator ( COMMA interfaceFieldDeclarator )* -> ^( VAR_DECLARATOR_LIST ( interfaceFieldDeclarator )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:580:9: interfaceFieldDeclarator ( COMMA interfaceFieldDeclarator )*
            {
                pushFollow(FOLLOW_interfaceFieldDeclarator_in_interfaceFieldDeclaratorList6315);
                interfaceFieldDeclarator130 = interfaceFieldDeclarator();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_interfaceFieldDeclarator.add(interfaceFieldDeclarator130.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:580:34: ( COMMA interfaceFieldDeclarator )*
                loop47:
                do
                {
                    int alt47 = 2;
                    int LA47_0 = input.LA(1);

                    if ((LA47_0 == COMMA))
                    {
                        alt47 = 1;
                    }


                    switch (alt47)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:580:35: COMMA interfaceFieldDeclarator
                        {
                            COMMA131 = (Token) match(input, COMMA, FOLLOW_COMMA_in_interfaceFieldDeclaratorList6318);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COMMA.add(COMMA131);

                            pushFollow(FOLLOW_interfaceFieldDeclarator_in_interfaceFieldDeclaratorList6320);
                            interfaceFieldDeclarator132 = interfaceFieldDeclarator();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_interfaceFieldDeclarator.add(interfaceFieldDeclarator132.getTree());

                        }
                        break;

                        default:
                            break loop47;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: interfaceFieldDeclarator
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 581:9: -> ^( VAR_DECLARATOR_LIST ( interfaceFieldDeclarator )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:581:13: ^( VAR_DECLARATOR_LIST ( interfaceFieldDeclarator )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATOR_LIST, "VAR_DECLARATOR_LIST"), root_1);

                            if (!(stream_interfaceFieldDeclarator.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_interfaceFieldDeclarator.hasNext())
                            {
                                adaptor.addChild(root_1, stream_interfaceFieldDeclarator.nextTree());

                            }
                            stream_interfaceFieldDeclarator.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 29, interfaceFieldDeclaratorList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "interfaceFieldDeclaratorList"

    public static class interfaceFieldDeclarator_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "interfaceFieldDeclarator"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:584:1: interfaceFieldDeclarator : variableDeclaratorId ASSIGN variableInitializer -> ^( VAR_DECLARATOR variableDeclaratorId variableInitializer ) ;

    public final JavaParser.interfaceFieldDeclarator_return interfaceFieldDeclarator() throws RecognitionException
    {
        JavaParser.interfaceFieldDeclarator_return retval = new JavaParser.interfaceFieldDeclarator_return();
        retval.start = input.LT(1);
        int interfaceFieldDeclarator_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ASSIGN134 = null;
        JavaParser.variableDeclaratorId_return variableDeclaratorId133 = null;

        JavaParser.variableInitializer_return variableInitializer135 = null;


        CommonTree ASSIGN134_tree = null;
        RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor, "token ASSIGN");
        RewriteRuleSubtreeStream stream_variableDeclaratorId = new RewriteRuleSubtreeStream(adaptor, "rule variableDeclaratorId");
        RewriteRuleSubtreeStream stream_variableInitializer = new RewriteRuleSubtreeStream(adaptor, "rule variableInitializer");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 30))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:585:5: ( variableDeclaratorId ASSIGN variableInitializer -> ^( VAR_DECLARATOR variableDeclaratorId variableInitializer ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:585:9: variableDeclaratorId ASSIGN variableInitializer
            {
                pushFollow(FOLLOW_variableDeclaratorId_in_interfaceFieldDeclarator6359);
                variableDeclaratorId133 = variableDeclaratorId();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_variableDeclaratorId.add(variableDeclaratorId133.getTree());
                ASSIGN134 = (Token) match(input, ASSIGN, FOLLOW_ASSIGN_in_interfaceFieldDeclarator6361);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_ASSIGN.add(ASSIGN134);

                pushFollow(FOLLOW_variableInitializer_in_interfaceFieldDeclarator6363);
                variableInitializer135 = variableInitializer();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_variableInitializer.add(variableInitializer135.getTree());


                // AST REWRITE
                // elements: variableInitializer, variableDeclaratorId
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 586:9: -> ^( VAR_DECLARATOR variableDeclaratorId variableInitializer )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:586:13: ^( VAR_DECLARATOR variableDeclaratorId variableInitializer )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATOR, "VAR_DECLARATOR"), root_1);

                            adaptor.addChild(root_1, stream_variableDeclaratorId.nextTree());
                            adaptor.addChild(root_1, stream_variableInitializer.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 30, interfaceFieldDeclarator_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "interfaceFieldDeclarator"

    public static class variableDeclaratorId_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "variableDeclaratorId"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:589:1: variableDeclaratorId : IDENT ( arrayDeclaratorList )? ;

    public final JavaParser.variableDeclaratorId_return variableDeclaratorId() throws RecognitionException
    {
        JavaParser.variableDeclaratorId_return retval = new JavaParser.variableDeclaratorId_return();
        retval.start = input.LT(1);
        int variableDeclaratorId_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT136 = null;
        JavaParser.arrayDeclaratorList_return arrayDeclaratorList137 = null;


        CommonTree IDENT136_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 31))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:590:5: ( IDENT ( arrayDeclaratorList )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:590:9: IDENT ( arrayDeclaratorList )?
            {
                root_0 = (CommonTree) adaptor.nil();

                IDENT136 = (Token) match(input, IDENT, FOLLOW_IDENT_in_variableDeclaratorId6401);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    IDENT136_tree = (CommonTree) adaptor.create(IDENT136);
                    root_0 = (CommonTree) adaptor.becomeRoot(IDENT136_tree, root_0);
                }
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:590:16: ( arrayDeclaratorList )?
                int alt48 = 2;
                int LA48_0 = input.LA(1);

                if ((LA48_0 == LBRACK))
                {
                    alt48 = 1;
                }
                switch (alt48)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                    {
                        pushFollow(FOLLOW_arrayDeclaratorList_in_variableDeclaratorId6404);
                        arrayDeclaratorList137 = arrayDeclaratorList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, arrayDeclaratorList137.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 31, variableDeclaratorId_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "variableDeclaratorId"

    public static class variableInitializer_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "variableInitializer"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:593:1: variableInitializer : ( arrayInitializer | expression );

    public final JavaParser.variableInitializer_return variableInitializer() throws RecognitionException
    {
        JavaParser.variableInitializer_return retval = new JavaParser.variableInitializer_return();
        retval.start = input.LT(1);
        int variableInitializer_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.arrayInitializer_return arrayInitializer138 = null;

        JavaParser.expression_return expression139 = null;


        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 32))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:594:5: ( arrayInitializer | expression )
            int alt49 = 2;
            int LA49_0 = input.LA(1);

            if ((LA49_0 == LCURLY))
            {
                alt49 = 1;
            }
            else if ((LA49_0 == DEC || LA49_0 == INC || LA49_0 == LESS_THAN || LA49_0 == LOGICAL_NOT || (LA49_0 >= LPAREN && LA49_0 <= MINUS) || LA49_0 == NOT || LA49_0 == PLUS || LA49_0 == BOOLEAN || LA49_0 == BYTE || LA49_0 == CHAR || LA49_0 == DOUBLE || LA49_0 == FALSE || LA49_0 == FLOAT || (LA49_0 >= INT && LA49_0 <= LONG) || (LA49_0 >= NEW && LA49_0 <= NULL) || LA49_0 == SHORT || LA49_0 == SUPER || LA49_0 == THIS || LA49_0 == TRUE || LA49_0 == VOID || (LA49_0 >= IDENT && LA49_0 <= STRING_LITERAL)))
            {
                alt49 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 49, 0, input);

                throw nvae;
            }
            switch (alt49)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:594:9: arrayInitializer
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_arrayInitializer_in_variableInitializer6424);
                    arrayInitializer138 = arrayInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, arrayInitializer138.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:595:9: expression
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_expression_in_variableInitializer6434);
                    expression139 = expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, expression139.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 32, variableInitializer_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "variableInitializer"

    public static class arrayDeclarator_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "arrayDeclarator"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:598:1: arrayDeclarator : LBRACK RBRACK -> ^( ARRAY_DECLARATOR ) ;

    public final JavaParser.arrayDeclarator_return arrayDeclarator() throws RecognitionException
    {
        JavaParser.arrayDeclarator_return retval = new JavaParser.arrayDeclarator_return();
        retval.start = input.LT(1);
        int arrayDeclarator_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LBRACK140 = null;
        Token RBRACK141 = null;

        CommonTree LBRACK140_tree = null;
        CommonTree RBRACK141_tree = null;
        RewriteRuleTokenStream stream_RBRACK = new RewriteRuleTokenStream(adaptor, "token RBRACK");
        RewriteRuleTokenStream stream_LBRACK = new RewriteRuleTokenStream(adaptor, "token LBRACK");

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 33))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:599:5: ( LBRACK RBRACK -> ^( ARRAY_DECLARATOR ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:599:9: LBRACK RBRACK
            {
                LBRACK140 = (Token) match(input, LBRACK, FOLLOW_LBRACK_in_arrayDeclarator6453);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LBRACK.add(LBRACK140);

                RBRACK141 = (Token) match(input, RBRACK, FOLLOW_RBRACK_in_arrayDeclarator6455);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RBRACK.add(RBRACK141);


                // AST REWRITE
                // elements:
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 600:9: -> ^( ARRAY_DECLARATOR )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:600:13: ^( ARRAY_DECLARATOR )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ARRAY_DECLARATOR, "ARRAY_DECLARATOR"), root_1);

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 33, arrayDeclarator_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "arrayDeclarator"

    public static class arrayDeclaratorList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "arrayDeclaratorList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:603:1: arrayDeclaratorList : ( arrayDeclarator )+ -> ^( ARRAY_DECLARATOR_LIST ( arrayDeclarator )+ ) ;

    public final JavaParser.arrayDeclaratorList_return arrayDeclaratorList() throws RecognitionException
    {
        JavaParser.arrayDeclaratorList_return retval = new JavaParser.arrayDeclaratorList_return();
        retval.start = input.LT(1);
        int arrayDeclaratorList_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.arrayDeclarator_return arrayDeclarator142 = null;


        RewriteRuleSubtreeStream stream_arrayDeclarator = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclarator");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 34))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:604:5: ( ( arrayDeclarator )+ -> ^( ARRAY_DECLARATOR_LIST ( arrayDeclarator )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:604:9: ( arrayDeclarator )+
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:604:9: ( arrayDeclarator )+
                int cnt50 = 0;
                loop50:
                do
                {
                    int alt50 = 2;
                    int LA50_0 = input.LA(1);

                    if ((LA50_0 == LBRACK))
                    {
                        int LA50_2 = input.LA(2);

                        if ((synpred59_Java()))
                        {
                            alt50 = 1;
                        }


                    }


                    switch (alt50)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclarator
                        {
                            pushFollow(FOLLOW_arrayDeclarator_in_arrayDeclaratorList6489);
                            arrayDeclarator142 = arrayDeclarator();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_arrayDeclarator.add(arrayDeclarator142.getTree());

                        }
                        break;

                        default:
                            if (cnt50 >= 1) break loop50;
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            EarlyExitException eee =
                                    new EarlyExitException(50, input);
                            throw eee;
                    }
                    cnt50++;
                }
                while (true);


                // AST REWRITE
                // elements: arrayDeclarator
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 605:9: -> ^( ARRAY_DECLARATOR_LIST ( arrayDeclarator )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:605:13: ^( ARRAY_DECLARATOR_LIST ( arrayDeclarator )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ARRAY_DECLARATOR_LIST, "ARRAY_DECLARATOR_LIST"), root_1);

                            if (!(stream_arrayDeclarator.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_arrayDeclarator.hasNext())
                            {
                                adaptor.addChild(root_1, stream_arrayDeclarator.nextTree());

                            }
                            stream_arrayDeclarator.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 34, arrayDeclaratorList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "arrayDeclaratorList"

    public static class arrayInitializer_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "arrayInitializer"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:608:1: arrayInitializer : LCURLY ( variableInitializer ( COMMA variableInitializer )* ( COMMA )? )? RCURLY -> ^( ARRAY_INITIALIZER[$LCURLY, \"ARRAY_INITIALIZER\"] ( variableInitializer )* ) ;

    public final JavaParser.arrayInitializer_return arrayInitializer() throws RecognitionException
    {
        JavaParser.arrayInitializer_return retval = new JavaParser.arrayInitializer_return();
        retval.start = input.LT(1);
        int arrayInitializer_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY143 = null;
        Token COMMA145 = null;
        Token COMMA147 = null;
        Token RCURLY148 = null;
        JavaParser.variableInitializer_return variableInitializer144 = null;

        JavaParser.variableInitializer_return variableInitializer146 = null;


        CommonTree LCURLY143_tree = null;
        CommonTree COMMA145_tree = null;
        CommonTree COMMA147_tree = null;
        CommonTree RCURLY148_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_variableInitializer = new RewriteRuleSubtreeStream(adaptor, "rule variableInitializer");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 35))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:5: ( LCURLY ( variableInitializer ( COMMA variableInitializer )* ( COMMA )? )? RCURLY -> ^( ARRAY_INITIALIZER[$LCURLY, \"ARRAY_INITIALIZER\"] ( variableInitializer )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:9: LCURLY ( variableInitializer ( COMMA variableInitializer )* ( COMMA )? )? RCURLY
            {
                LCURLY143 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_arrayInitializer6527);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY143);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:16: ( variableInitializer ( COMMA variableInitializer )* ( COMMA )? )?
                int alt53 = 2;
                int LA53_0 = input.LA(1);

                if ((LA53_0 == DEC || LA53_0 == INC || LA53_0 == LCURLY || LA53_0 == LESS_THAN || LA53_0 == LOGICAL_NOT || (LA53_0 >= LPAREN && LA53_0 <= MINUS) || LA53_0 == NOT || LA53_0 == PLUS || LA53_0 == BOOLEAN || LA53_0 == BYTE || LA53_0 == CHAR || LA53_0 == DOUBLE || LA53_0 == FALSE || LA53_0 == FLOAT || (LA53_0 >= INT && LA53_0 <= LONG) || (LA53_0 >= NEW && LA53_0 <= NULL) || LA53_0 == SHORT || LA53_0 == SUPER || LA53_0 == THIS || LA53_0 == TRUE || LA53_0 == VOID || (LA53_0 >= IDENT && LA53_0 <= STRING_LITERAL)))
                {
                    alt53 = 1;
                }
                switch (alt53)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:17: variableInitializer ( COMMA variableInitializer )* ( COMMA )?
                    {
                        pushFollow(FOLLOW_variableInitializer_in_arrayInitializer6530);
                        variableInitializer144 = variableInitializer();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_variableInitializer.add(variableInitializer144.getTree());
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:37: ( COMMA variableInitializer )*
                        loop51:
                        do
                        {
                            int alt51 = 2;
                            int LA51_0 = input.LA(1);

                            if ((LA51_0 == COMMA))
                            {
                                int LA51_1 = input.LA(2);

                                if ((LA51_1 == DEC || LA51_1 == INC || LA51_1 == LCURLY || LA51_1 == LESS_THAN || LA51_1 == LOGICAL_NOT || (LA51_1 >= LPAREN && LA51_1 <= MINUS) || LA51_1 == NOT || LA51_1 == PLUS || LA51_1 == BOOLEAN || LA51_1 == BYTE || LA51_1 == CHAR || LA51_1 == DOUBLE || LA51_1 == FALSE || LA51_1 == FLOAT || (LA51_1 >= INT && LA51_1 <= LONG) || (LA51_1 >= NEW && LA51_1 <= NULL) || LA51_1 == SHORT || LA51_1 == SUPER || LA51_1 == THIS || LA51_1 == TRUE || LA51_1 == VOID || (LA51_1 >= IDENT && LA51_1 <= STRING_LITERAL)))
                                {
                                    alt51 = 1;
                                }


                            }


                            switch (alt51)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:38: COMMA variableInitializer
                                {
                                    COMMA145 = (Token) match(input, COMMA, FOLLOW_COMMA_in_arrayInitializer6533);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_COMMA.add(COMMA145);

                                    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer6535);
                                    variableInitializer146 = variableInitializer();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_variableInitializer.add(variableInitializer146.getTree());

                                }
                                break;

                                default:
                                    break loop51;
                            }
                        }
                        while (true);

                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:609:66: ( COMMA )?
                        int alt52 = 2;
                        int LA52_0 = input.LA(1);

                        if ((LA52_0 == COMMA))
                        {
                            alt52 = 1;
                        }
                        switch (alt52)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: COMMA
                            {
                                COMMA147 = (Token) match(input, COMMA, FOLLOW_COMMA_in_arrayInitializer6539);
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_COMMA.add(COMMA147);


                            }
                            break;

                        }


                    }
                    break;

                }

                RCURLY148 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_arrayInitializer6544);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY148);


                // AST REWRITE
                // elements: variableInitializer
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 610:9: -> ^( ARRAY_INITIALIZER[$LCURLY, \"ARRAY_INITIALIZER\"] ( variableInitializer )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:610:13: ^( ARRAY_INITIALIZER[$LCURLY, \"ARRAY_INITIALIZER\"] ( variableInitializer )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ARRAY_INITIALIZER, LCURLY143, "ARRAY_INITIALIZER"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:610:63: ( variableInitializer )*
                            while (stream_variableInitializer.hasNext())
                            {
                                adaptor.addChild(root_1, stream_variableInitializer.nextTree());

                            }
                            stream_variableInitializer.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 35, arrayInitializer_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "arrayInitializer"

    public static class throwsClause_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "throwsClause"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:613:1: throwsClause : THROWS qualifiedIdentList -> ^( THROWS_CLAUSE[$THROWS, \"THROWS_CLAUSE\"] qualifiedIdentList ) ;

    public final JavaParser.throwsClause_return throwsClause() throws RecognitionException
    {
        JavaParser.throwsClause_return retval = new JavaParser.throwsClause_return();
        retval.start = input.LT(1);
        int throwsClause_StartIndex = input.index();
        CommonTree root_0 = null;

        Token THROWS149 = null;
        JavaParser.qualifiedIdentList_return qualifiedIdentList150 = null;


        CommonTree THROWS149_tree = null;
        RewriteRuleTokenStream stream_THROWS = new RewriteRuleTokenStream(adaptor, "token THROWS");
        RewriteRuleSubtreeStream stream_qualifiedIdentList = new RewriteRuleSubtreeStream(adaptor, "rule qualifiedIdentList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 36))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:614:5: ( THROWS qualifiedIdentList -> ^( THROWS_CLAUSE[$THROWS, \"THROWS_CLAUSE\"] qualifiedIdentList ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:614:9: THROWS qualifiedIdentList
            {
                THROWS149 = (Token) match(input, THROWS, FOLLOW_THROWS_in_throwsClause6582);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_THROWS.add(THROWS149);

                pushFollow(FOLLOW_qualifiedIdentList_in_throwsClause6584);
                qualifiedIdentList150 = qualifiedIdentList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_qualifiedIdentList.add(qualifiedIdentList150.getTree());


                // AST REWRITE
                // elements: qualifiedIdentList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 615:9: -> ^( THROWS_CLAUSE[$THROWS, \"THROWS_CLAUSE\"] qualifiedIdentList )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:615:13: ^( THROWS_CLAUSE[$THROWS, \"THROWS_CLAUSE\"] qualifiedIdentList )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(THROWS_CLAUSE, THROWS149, "THROWS_CLAUSE"), root_1);

                            adaptor.addChild(root_1, stream_qualifiedIdentList.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 36, throwsClause_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "throwsClause"

    public static class modifierList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "modifierList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:618:1: modifierList : ( modifier )* -> ^( MODIFIER_LIST ( modifier )* ) ;

    public final JavaParser.modifierList_return modifierList() throws RecognitionException
    {
        JavaParser.modifierList_return retval = new JavaParser.modifierList_return();
        retval.start = input.LT(1);
        int modifierList_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.modifier_return modifier151 = null;


        RewriteRuleSubtreeStream stream_modifier = new RewriteRuleSubtreeStream(adaptor, "rule modifier");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 37))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:619:5: ( ( modifier )* -> ^( MODIFIER_LIST ( modifier )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:619:9: ( modifier )*
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:619:9: ( modifier )*
                loop54:
                do
                {
                    int alt54 = 2;
                    int LA54_0 = input.LA(1);

                    if ((LA54_0 == AT))
                    {
                        int LA54_2 = input.LA(2);

                        if ((LA54_2 == IDENT))
                        {
                            alt54 = 1;
                        }


                    }
                    else if ((LA54_0 == ABSTRACT || LA54_0 == FINAL || LA54_0 == NATIVE || (LA54_0 >= PRIVATE && LA54_0 <= PUBLIC) || (LA54_0 >= STATIC && LA54_0 <= STRICTFP) || LA54_0 == SYNCHRONIZED || LA54_0 == TRANSIENT || LA54_0 == VOLATILE))
                    {
                        alt54 = 1;
                    }


                    switch (alt54)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: modifier
                        {
                            pushFollow(FOLLOW_modifier_in_modifierList6621);
                            modifier151 = modifier();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_modifier.add(modifier151.getTree());

                        }
                        break;

                        default:
                            break loop54;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: modifier
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 620:9: -> ^( MODIFIER_LIST ( modifier )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:620:13: ^( MODIFIER_LIST ( modifier )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(MODIFIER_LIST, "MODIFIER_LIST"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:620:29: ( modifier )*
                            while (stream_modifier.hasNext())
                            {
                                adaptor.addChild(root_1, stream_modifier.nextTree());

                            }
                            stream_modifier.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 37, modifierList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "modifierList"

    public static class modifier_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "modifier"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:623:1: modifier : ( PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP | localModifier );

    public final JavaParser.modifier_return modifier() throws RecognitionException
    {
        JavaParser.modifier_return retval = new JavaParser.modifier_return();
        retval.start = input.LT(1);
        int modifier_StartIndex = input.index();
        CommonTree root_0 = null;

        Token PUBLIC152 = null;
        Token PROTECTED153 = null;
        Token PRIVATE154 = null;
        Token STATIC155 = null;
        Token ABSTRACT156 = null;
        Token NATIVE157 = null;
        Token SYNCHRONIZED158 = null;
        Token TRANSIENT159 = null;
        Token VOLATILE160 = null;
        Token STRICTFP161 = null;
        JavaParser.localModifier_return localModifier162 = null;


        CommonTree PUBLIC152_tree = null;
        CommonTree PROTECTED153_tree = null;
        CommonTree PRIVATE154_tree = null;
        CommonTree STATIC155_tree = null;
        CommonTree ABSTRACT156_tree = null;
        CommonTree NATIVE157_tree = null;
        CommonTree SYNCHRONIZED158_tree = null;
        CommonTree TRANSIENT159_tree = null;
        CommonTree VOLATILE160_tree = null;
        CommonTree STRICTFP161_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 38))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:624:5: ( PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP | localModifier )
            int alt55 = 11;
            switch (input.LA(1))
            {
                case PUBLIC:
                {
                    alt55 = 1;
                }
                break;
                case PROTECTED:
                {
                    alt55 = 2;
                }
                break;
                case PRIVATE:
                {
                    alt55 = 3;
                }
                break;
                case STATIC:
                {
                    alt55 = 4;
                }
                break;
                case ABSTRACT:
                {
                    alt55 = 5;
                }
                break;
                case NATIVE:
                {
                    alt55 = 6;
                }
                break;
                case SYNCHRONIZED:
                {
                    alt55 = 7;
                }
                break;
                case TRANSIENT:
                {
                    alt55 = 8;
                }
                break;
                case VOLATILE:
                {
                    alt55 = 9;
                }
                break;
                case STRICTFP:
                {
                    alt55 = 10;
                }
                break;
                case AT:
                case FINAL:
                {
                    alt55 = 11;
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 55, 0, input);

                    throw nvae;
            }

            switch (alt55)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:624:9: PUBLIC
                {
                    root_0 = (CommonTree) adaptor.nil();

                    PUBLIC152 = (Token) match(input, PUBLIC, FOLLOW_PUBLIC_in_modifier6659);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        PUBLIC152_tree = (CommonTree) adaptor.create(PUBLIC152);
                        adaptor.addChild(root_0, PUBLIC152_tree);
                    }

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:625:9: PROTECTED
                {
                    root_0 = (CommonTree) adaptor.nil();

                    PROTECTED153 = (Token) match(input, PROTECTED, FOLLOW_PROTECTED_in_modifier6669);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        PROTECTED153_tree = (CommonTree) adaptor.create(PROTECTED153);
                        adaptor.addChild(root_0, PROTECTED153_tree);
                    }

                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:626:9: PRIVATE
                {
                    root_0 = (CommonTree) adaptor.nil();

                    PRIVATE154 = (Token) match(input, PRIVATE, FOLLOW_PRIVATE_in_modifier6679);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        PRIVATE154_tree = (CommonTree) adaptor.create(PRIVATE154);
                        adaptor.addChild(root_0, PRIVATE154_tree);
                    }

                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:627:9: STATIC
                {
                    root_0 = (CommonTree) adaptor.nil();

                    STATIC155 = (Token) match(input, STATIC, FOLLOW_STATIC_in_modifier6689);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        STATIC155_tree = (CommonTree) adaptor.create(STATIC155);
                        adaptor.addChild(root_0, STATIC155_tree);
                    }

                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:628:9: ABSTRACT
                {
                    root_0 = (CommonTree) adaptor.nil();

                    ABSTRACT156 = (Token) match(input, ABSTRACT, FOLLOW_ABSTRACT_in_modifier6699);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        ABSTRACT156_tree = (CommonTree) adaptor.create(ABSTRACT156);
                        adaptor.addChild(root_0, ABSTRACT156_tree);
                    }

                }
                break;
                case 6:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:629:9: NATIVE
                {
                    root_0 = (CommonTree) adaptor.nil();

                    NATIVE157 = (Token) match(input, NATIVE, FOLLOW_NATIVE_in_modifier6709);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        NATIVE157_tree = (CommonTree) adaptor.create(NATIVE157);
                        adaptor.addChild(root_0, NATIVE157_tree);
                    }

                }
                break;
                case 7:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:630:9: SYNCHRONIZED
                {
                    root_0 = (CommonTree) adaptor.nil();

                    SYNCHRONIZED158 = (Token) match(input, SYNCHRONIZED, FOLLOW_SYNCHRONIZED_in_modifier6719);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        SYNCHRONIZED158_tree = (CommonTree) adaptor.create(SYNCHRONIZED158);
                        adaptor.addChild(root_0, SYNCHRONIZED158_tree);
                    }

                }
                break;
                case 8:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:631:9: TRANSIENT
                {
                    root_0 = (CommonTree) adaptor.nil();

                    TRANSIENT159 = (Token) match(input, TRANSIENT, FOLLOW_TRANSIENT_in_modifier6729);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        TRANSIENT159_tree = (CommonTree) adaptor.create(TRANSIENT159);
                        adaptor.addChild(root_0, TRANSIENT159_tree);
                    }

                }
                break;
                case 9:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:632:9: VOLATILE
                {
                    root_0 = (CommonTree) adaptor.nil();

                    VOLATILE160 = (Token) match(input, VOLATILE, FOLLOW_VOLATILE_in_modifier6739);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        VOLATILE160_tree = (CommonTree) adaptor.create(VOLATILE160);
                        adaptor.addChild(root_0, VOLATILE160_tree);
                    }

                }
                break;
                case 10:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:633:9: STRICTFP
                {
                    root_0 = (CommonTree) adaptor.nil();

                    STRICTFP161 = (Token) match(input, STRICTFP, FOLLOW_STRICTFP_in_modifier6749);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        STRICTFP161_tree = (CommonTree) adaptor.create(STRICTFP161);
                        adaptor.addChild(root_0, STRICTFP161_tree);
                    }

                }
                break;
                case 11:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:634:9: localModifier
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_localModifier_in_modifier6759);
                    localModifier162 = localModifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, localModifier162.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 38, modifier_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "modifier"

    public static class localModifierList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "localModifierList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:637:1: localModifierList : ( localModifier )* -> ^( LOCAL_MODIFIER_LIST ( localModifier )* ) ;

    public final JavaParser.localModifierList_return localModifierList() throws RecognitionException
    {
        JavaParser.localModifierList_return retval = new JavaParser.localModifierList_return();
        retval.start = input.LT(1);
        int localModifierList_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.localModifier_return localModifier163 = null;


        RewriteRuleSubtreeStream stream_localModifier = new RewriteRuleSubtreeStream(adaptor, "rule localModifier");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 39))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:638:5: ( ( localModifier )* -> ^( LOCAL_MODIFIER_LIST ( localModifier )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:638:9: ( localModifier )*
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:638:9: ( localModifier )*
                loop56:
                do
                {
                    int alt56 = 2;
                    int LA56_0 = input.LA(1);

                    if ((LA56_0 == AT || LA56_0 == FINAL))
                    {
                        alt56 = 1;
                    }


                    switch (alt56)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: localModifier
                        {
                            pushFollow(FOLLOW_localModifier_in_localModifierList6778);
                            localModifier163 = localModifier();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_localModifier.add(localModifier163.getTree());

                        }
                        break;

                        default:
                            break loop56;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: localModifier
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 639:9: -> ^( LOCAL_MODIFIER_LIST ( localModifier )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:639:12: ^( LOCAL_MODIFIER_LIST ( localModifier )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(LOCAL_MODIFIER_LIST, "LOCAL_MODIFIER_LIST"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:639:34: ( localModifier )*
                            while (stream_localModifier.hasNext())
                            {
                                adaptor.addChild(root_1, stream_localModifier.nextTree());

                            }
                            stream_localModifier.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 39, localModifierList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "localModifierList"

    public static class localModifier_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "localModifier"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:642:1: localModifier : ( FINAL | annotation );

    public final JavaParser.localModifier_return localModifier() throws RecognitionException
    {
        JavaParser.localModifier_return retval = new JavaParser.localModifier_return();
        retval.start = input.LT(1);
        int localModifier_StartIndex = input.index();
        CommonTree root_0 = null;

        Token FINAL164 = null;
        JavaParser.annotation_return annotation165 = null;


        CommonTree FINAL164_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 40))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:643:5: ( FINAL | annotation )
            int alt57 = 2;
            int LA57_0 = input.LA(1);

            if ((LA57_0 == FINAL))
            {
                alt57 = 1;
            }
            else if ((LA57_0 == AT))
            {
                alt57 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 57, 0, input);

                throw nvae;
            }
            switch (alt57)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:643:9: FINAL
                {
                    root_0 = (CommonTree) adaptor.nil();

                    FINAL164 = (Token) match(input, FINAL, FOLLOW_FINAL_in_localModifier6815);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        FINAL164_tree = (CommonTree) adaptor.create(FINAL164);
                        adaptor.addChild(root_0, FINAL164_tree);
                    }

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:644:9: annotation
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_annotation_in_localModifier6825);
                    annotation165 = annotation();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, annotation165.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 40, localModifier_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "localModifier"

    public static class type_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "type"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:647:1: type : ( simpleType | objectType );

    public final JavaParser.type_return type() throws RecognitionException
    {
        JavaParser.type_return retval = new JavaParser.type_return();
        retval.start = input.LT(1);
        int type_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.simpleType_return simpleType166 = null;

        JavaParser.objectType_return objectType167 = null;


        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 41))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:648:5: ( simpleType | objectType )
            int alt58 = 2;
            int LA58_0 = input.LA(1);

            if ((LA58_0 == BOOLEAN || LA58_0 == BYTE || LA58_0 == CHAR || LA58_0 == DOUBLE || LA58_0 == FLOAT || (LA58_0 >= INT && LA58_0 <= LONG) || LA58_0 == SHORT))
            {
                alt58 = 1;
            }
            else if ((LA58_0 == IDENT))
            {
                alt58 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 58, 0, input);

                throw nvae;
            }
            switch (alt58)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:648:9: simpleType
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_simpleType_in_type6844);
                    simpleType166 = simpleType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, simpleType166.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:649:9: objectType
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_objectType_in_type6854);
                    objectType167 = objectType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, objectType167.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 41, type_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "type"

    public static class simpleType_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "simpleType"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:652:1: simpleType : primitiveType ( arrayDeclaratorList )? -> ^( TYPE primitiveType ( arrayDeclaratorList )? ) ;

    public final JavaParser.simpleType_return simpleType() throws RecognitionException
    {
        JavaParser.simpleType_return retval = new JavaParser.simpleType_return();
        retval.start = input.LT(1);
        int simpleType_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.primitiveType_return primitiveType168 = null;

        JavaParser.arrayDeclaratorList_return arrayDeclaratorList169 = null;


        RewriteRuleSubtreeStream stream_arrayDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclaratorList");
        RewriteRuleSubtreeStream stream_primitiveType = new RewriteRuleSubtreeStream(adaptor, "rule primitiveType");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 42))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:653:5: ( primitiveType ( arrayDeclaratorList )? -> ^( TYPE primitiveType ( arrayDeclaratorList )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:653:9: primitiveType ( arrayDeclaratorList )?
            {
                pushFollow(FOLLOW_primitiveType_in_simpleType6874);
                primitiveType168 = primitiveType();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_primitiveType.add(primitiveType168.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:653:23: ( arrayDeclaratorList )?
                int alt59 = 2;
                int LA59_0 = input.LA(1);

                if ((LA59_0 == LBRACK))
                {
                    int LA59_1 = input.LA(2);

                    if ((LA59_1 == RBRACK))
                    {
                        int LA59_3 = input.LA(3);

                        if ((synpred77_Java()))
                        {
                            alt59 = 1;
                        }
                    }
                }
                switch (alt59)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                    {
                        pushFollow(FOLLOW_arrayDeclaratorList_in_simpleType6876);
                        arrayDeclaratorList169 = arrayDeclaratorList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_arrayDeclaratorList.add(arrayDeclaratorList169.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: arrayDeclaratorList, primitiveType
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 654:9: -> ^( TYPE primitiveType ( arrayDeclaratorList )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:654:13: ^( TYPE primitiveType ( arrayDeclaratorList )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(TYPE, "TYPE"), root_1);

                            adaptor.addChild(root_1, stream_primitiveType.nextTree());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:654:34: ( arrayDeclaratorList )?
                            if (stream_arrayDeclaratorList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_arrayDeclaratorList.nextTree());

                            }
                            stream_arrayDeclaratorList.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 42, simpleType_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "simpleType"

    public static class objectType_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "objectType"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:657:1: objectType : qualifiedTypeIdent ( arrayDeclaratorList )? -> ^( TYPE qualifiedTypeIdent ( arrayDeclaratorList )? ) ;

    public final JavaParser.objectType_return objectType() throws RecognitionException
    {
        JavaParser.objectType_return retval = new JavaParser.objectType_return();
        retval.start = input.LT(1);
        int objectType_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.qualifiedTypeIdent_return qualifiedTypeIdent170 = null;

        JavaParser.arrayDeclaratorList_return arrayDeclaratorList171 = null;


        RewriteRuleSubtreeStream stream_arrayDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclaratorList");
        RewriteRuleSubtreeStream stream_qualifiedTypeIdent = new RewriteRuleSubtreeStream(adaptor, "rule qualifiedTypeIdent");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 43))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:658:5: ( qualifiedTypeIdent ( arrayDeclaratorList )? -> ^( TYPE qualifiedTypeIdent ( arrayDeclaratorList )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:658:9: qualifiedTypeIdent ( arrayDeclaratorList )?
            {
                pushFollow(FOLLOW_qualifiedTypeIdent_in_objectType6917);
                qualifiedTypeIdent170 = qualifiedTypeIdent();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_qualifiedTypeIdent.add(qualifiedTypeIdent170.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:658:28: ( arrayDeclaratorList )?
                int alt60 = 2;
                int LA60_0 = input.LA(1);

                if ((LA60_0 == LBRACK))
                {
                    int LA60_1 = input.LA(2);

                    if ((synpred78_Java()))
                    {
                        alt60 = 1;
                    }
                }
                switch (alt60)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                    {
                        pushFollow(FOLLOW_arrayDeclaratorList_in_objectType6919);
                        arrayDeclaratorList171 = arrayDeclaratorList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_arrayDeclaratorList.add(arrayDeclaratorList171.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: qualifiedTypeIdent, arrayDeclaratorList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 659:9: -> ^( TYPE qualifiedTypeIdent ( arrayDeclaratorList )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:659:13: ^( TYPE qualifiedTypeIdent ( arrayDeclaratorList )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(TYPE, "TYPE"), root_1);

                            adaptor.addChild(root_1, stream_qualifiedTypeIdent.nextTree());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:659:39: ( arrayDeclaratorList )?
                            if (stream_arrayDeclaratorList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_arrayDeclaratorList.nextTree());

                            }
                            stream_arrayDeclaratorList.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 43, objectType_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "objectType"

    public static class objectTypeSimplified_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "objectTypeSimplified"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:662:1: objectTypeSimplified : qualifiedTypeIdentSimplified ( arrayDeclaratorList )? -> ^( TYPE qualifiedTypeIdentSimplified ( arrayDeclaratorList )? ) ;

    public final JavaParser.objectTypeSimplified_return objectTypeSimplified() throws RecognitionException
    {
        JavaParser.objectTypeSimplified_return retval = new JavaParser.objectTypeSimplified_return();
        retval.start = input.LT(1);
        int objectTypeSimplified_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.qualifiedTypeIdentSimplified_return qualifiedTypeIdentSimplified172 = null;

        JavaParser.arrayDeclaratorList_return arrayDeclaratorList173 = null;


        RewriteRuleSubtreeStream stream_arrayDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclaratorList");
        RewriteRuleSubtreeStream stream_qualifiedTypeIdentSimplified = new RewriteRuleSubtreeStream(adaptor, "rule qualifiedTypeIdentSimplified");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 44))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:663:5: ( qualifiedTypeIdentSimplified ( arrayDeclaratorList )? -> ^( TYPE qualifiedTypeIdentSimplified ( arrayDeclaratorList )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:663:9: qualifiedTypeIdentSimplified ( arrayDeclaratorList )?
            {
                pushFollow(FOLLOW_qualifiedTypeIdentSimplified_in_objectTypeSimplified6959);
                qualifiedTypeIdentSimplified172 = qualifiedTypeIdentSimplified();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0)
                    stream_qualifiedTypeIdentSimplified.add(qualifiedTypeIdentSimplified172.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:663:38: ( arrayDeclaratorList )?
                int alt61 = 2;
                int LA61_0 = input.LA(1);

                if ((LA61_0 == LBRACK))
                {
                    alt61 = 1;
                }
                switch (alt61)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                    {
                        pushFollow(FOLLOW_arrayDeclaratorList_in_objectTypeSimplified6961);
                        arrayDeclaratorList173 = arrayDeclaratorList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_arrayDeclaratorList.add(arrayDeclaratorList173.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: qualifiedTypeIdentSimplified, arrayDeclaratorList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 664:9: -> ^( TYPE qualifiedTypeIdentSimplified ( arrayDeclaratorList )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:664:13: ^( TYPE qualifiedTypeIdentSimplified ( arrayDeclaratorList )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(TYPE, "TYPE"), root_1);

                            adaptor.addChild(root_1, stream_qualifiedTypeIdentSimplified.nextTree());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:664:49: ( arrayDeclaratorList )?
                            if (stream_arrayDeclaratorList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_arrayDeclaratorList.nextTree());

                            }
                            stream_arrayDeclaratorList.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 44, objectTypeSimplified_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "objectTypeSimplified"

    public static class qualifiedTypeIdent_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "qualifiedTypeIdent"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:667:1: qualifiedTypeIdent : typeIdent ( DOT typeIdent )* -> ^( QUALIFIED_TYPE_IDENT ( typeIdent )+ ) ;

    public final JavaParser.qualifiedTypeIdent_return qualifiedTypeIdent() throws RecognitionException
    {
        JavaParser.qualifiedTypeIdent_return retval = new JavaParser.qualifiedTypeIdent_return();
        retval.start = input.LT(1);
        int qualifiedTypeIdent_StartIndex = input.index();
        CommonTree root_0 = null;

        Token DOT175 = null;
        JavaParser.typeIdent_return typeIdent174 = null;

        JavaParser.typeIdent_return typeIdent176 = null;


        CommonTree DOT175_tree = null;
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor, "token DOT");
        RewriteRuleSubtreeStream stream_typeIdent = new RewriteRuleSubtreeStream(adaptor, "rule typeIdent");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 45))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:668:5: ( typeIdent ( DOT typeIdent )* -> ^( QUALIFIED_TYPE_IDENT ( typeIdent )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:668:9: typeIdent ( DOT typeIdent )*
            {
                pushFollow(FOLLOW_typeIdent_in_qualifiedTypeIdent7001);
                typeIdent174 = typeIdent();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_typeIdent.add(typeIdent174.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:668:19: ( DOT typeIdent )*
                loop62:
                do
                {
                    int alt62 = 2;
                    int LA62_0 = input.LA(1);

                    if ((LA62_0 == DOT))
                    {
                        int LA62_2 = input.LA(2);

                        if ((synpred80_Java()))
                        {
                            alt62 = 1;
                        }


                    }


                    switch (alt62)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:668:20: DOT typeIdent
                        {
                            DOT175 = (Token) match(input, DOT, FOLLOW_DOT_in_qualifiedTypeIdent7004);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_DOT.add(DOT175);

                            pushFollow(FOLLOW_typeIdent_in_qualifiedTypeIdent7006);
                            typeIdent176 = typeIdent();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_typeIdent.add(typeIdent176.getTree());

                        }
                        break;

                        default:
                            break loop62;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: typeIdent
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 669:9: -> ^( QUALIFIED_TYPE_IDENT ( typeIdent )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:669:13: ^( QUALIFIED_TYPE_IDENT ( typeIdent )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(QUALIFIED_TYPE_IDENT, "QUALIFIED_TYPE_IDENT"), root_1);

                            if (!(stream_typeIdent.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_typeIdent.hasNext())
                            {
                                adaptor.addChild(root_1, stream_typeIdent.nextTree());

                            }
                            stream_typeIdent.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 45, qualifiedTypeIdent_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "qualifiedTypeIdent"

    public static class qualifiedTypeIdentSimplified_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "qualifiedTypeIdentSimplified"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:672:1: qualifiedTypeIdentSimplified : typeIdentSimplified ( DOT typeIdentSimplified )* -> ^( QUALIFIED_TYPE_IDENT ( typeIdentSimplified )+ ) ;

    public final JavaParser.qualifiedTypeIdentSimplified_return qualifiedTypeIdentSimplified() throws RecognitionException
    {
        JavaParser.qualifiedTypeIdentSimplified_return retval = new JavaParser.qualifiedTypeIdentSimplified_return();
        retval.start = input.LT(1);
        int qualifiedTypeIdentSimplified_StartIndex = input.index();
        CommonTree root_0 = null;

        Token DOT178 = null;
        JavaParser.typeIdentSimplified_return typeIdentSimplified177 = null;

        JavaParser.typeIdentSimplified_return typeIdentSimplified179 = null;


        CommonTree DOT178_tree = null;
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor, "token DOT");
        RewriteRuleSubtreeStream stream_typeIdentSimplified = new RewriteRuleSubtreeStream(adaptor, "rule typeIdentSimplified");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 46))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:673:5: ( typeIdentSimplified ( DOT typeIdentSimplified )* -> ^( QUALIFIED_TYPE_IDENT ( typeIdentSimplified )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:673:9: typeIdentSimplified ( DOT typeIdentSimplified )*
            {
                pushFollow(FOLLOW_typeIdentSimplified_in_qualifiedTypeIdentSimplified7045);
                typeIdentSimplified177 = typeIdentSimplified();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_typeIdentSimplified.add(typeIdentSimplified177.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:673:29: ( DOT typeIdentSimplified )*
                loop63:
                do
                {
                    int alt63 = 2;
                    int LA63_0 = input.LA(1);

                    if ((LA63_0 == DOT))
                    {
                        alt63 = 1;
                    }


                    switch (alt63)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:673:30: DOT typeIdentSimplified
                        {
                            DOT178 = (Token) match(input, DOT, FOLLOW_DOT_in_qualifiedTypeIdentSimplified7048);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_DOT.add(DOT178);

                            pushFollow(FOLLOW_typeIdentSimplified_in_qualifiedTypeIdentSimplified7050);
                            typeIdentSimplified179 = typeIdentSimplified();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_typeIdentSimplified.add(typeIdentSimplified179.getTree());

                        }
                        break;

                        default:
                            break loop63;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: typeIdentSimplified
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 674:9: -> ^( QUALIFIED_TYPE_IDENT ( typeIdentSimplified )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:674:13: ^( QUALIFIED_TYPE_IDENT ( typeIdentSimplified )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(QUALIFIED_TYPE_IDENT, "QUALIFIED_TYPE_IDENT"), root_1);

                            if (!(stream_typeIdentSimplified.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_typeIdentSimplified.hasNext())
                            {
                                adaptor.addChild(root_1, stream_typeIdentSimplified.nextTree());

                            }
                            stream_typeIdentSimplified.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 46, qualifiedTypeIdentSimplified_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "qualifiedTypeIdentSimplified"

    public static class typeIdent_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "typeIdent"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:677:1: typeIdent : IDENT ( genericTypeArgumentList )? ;

    public final JavaParser.typeIdent_return typeIdent() throws RecognitionException
    {
        JavaParser.typeIdent_return retval = new JavaParser.typeIdent_return();
        retval.start = input.LT(1);
        int typeIdent_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT180 = null;
        JavaParser.genericTypeArgumentList_return genericTypeArgumentList181 = null;


        CommonTree IDENT180_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 47))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:678:5: ( IDENT ( genericTypeArgumentList )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:678:9: IDENT ( genericTypeArgumentList )?
            {
                root_0 = (CommonTree) adaptor.nil();

                IDENT180 = (Token) match(input, IDENT, FOLLOW_IDENT_in_typeIdent7089);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    IDENT180_tree = (CommonTree) adaptor.create(IDENT180);
                    root_0 = (CommonTree) adaptor.becomeRoot(IDENT180_tree, root_0);
                }
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:678:16: ( genericTypeArgumentList )?
                int alt64 = 2;
                int LA64_0 = input.LA(1);

                if ((LA64_0 == LESS_THAN))
                {
                    alt64 = 1;
                }
                switch (alt64)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeArgumentList
                    {
                        pushFollow(FOLLOW_genericTypeArgumentList_in_typeIdent7092);
                        genericTypeArgumentList181 = genericTypeArgumentList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, genericTypeArgumentList181.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 47, typeIdent_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "typeIdent"

    public static class typeIdentSimplified_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "typeIdentSimplified"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:681:1: typeIdentSimplified : IDENT ( genericTypeArgumentListSimplified )? ;

    public final JavaParser.typeIdentSimplified_return typeIdentSimplified() throws RecognitionException
    {
        JavaParser.typeIdentSimplified_return retval = new JavaParser.typeIdentSimplified_return();
        retval.start = input.LT(1);
        int typeIdentSimplified_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT182 = null;
        JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified183 = null;


        CommonTree IDENT182_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 48))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:682:5: ( IDENT ( genericTypeArgumentListSimplified )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:682:9: IDENT ( genericTypeArgumentListSimplified )?
            {
                root_0 = (CommonTree) adaptor.nil();

                IDENT182 = (Token) match(input, IDENT, FOLLOW_IDENT_in_typeIdentSimplified7112);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    IDENT182_tree = (CommonTree) adaptor.create(IDENT182);
                    root_0 = (CommonTree) adaptor.becomeRoot(IDENT182_tree, root_0);
                }
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:682:16: ( genericTypeArgumentListSimplified )?
                int alt65 = 2;
                int LA65_0 = input.LA(1);

                if ((LA65_0 == LESS_THAN))
                {
                    alt65 = 1;
                }
                switch (alt65)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeArgumentListSimplified
                    {
                        pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_typeIdentSimplified7115);
                        genericTypeArgumentListSimplified183 = genericTypeArgumentListSimplified();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            adaptor.addChild(root_0, genericTypeArgumentListSimplified183.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 48, typeIdentSimplified_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "typeIdentSimplified"

    public static class primitiveType_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "primitiveType"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:685:1: primitiveType : ( BOOLEAN | CHAR | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE );

    public final JavaParser.primitiveType_return primitiveType() throws RecognitionException
    {
        JavaParser.primitiveType_return retval = new JavaParser.primitiveType_return();
        retval.start = input.LT(1);
        int primitiveType_StartIndex = input.index();
        CommonTree root_0 = null;

        Token set184 = null;

        CommonTree set184_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 49))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:686:5: ( BOOLEAN | CHAR | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:
            {
                root_0 = (CommonTree) adaptor.nil();

                set184 = (Token) input.LT(1);
                if (input.LA(1) == BOOLEAN || input.LA(1) == BYTE || input.LA(1) == CHAR || input.LA(1) == DOUBLE || input.LA(1) == FLOAT || (input.LA(1) >= INT && input.LA(1) <= LONG) || input.LA(1) == SHORT)
                {
                    input.consume();
                    if (state.backtracking == 0) adaptor.addChild(root_0, (CommonTree) adaptor.create(set184));
                    state.errorRecovery = false;
                    state.failed = false;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    MismatchedSetException mse = new MismatchedSetException(null, input);
                    throw mse;
                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 49, primitiveType_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "primitiveType"

    public static class genericTypeArgumentList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeArgumentList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:696:1: genericTypeArgumentList : LESS_THAN genericTypeArgument ( COMMA genericTypeArgument )* genericTypeListClosing -> ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgument )+ ) ;

    public final JavaParser.genericTypeArgumentList_return genericTypeArgumentList() throws RecognitionException
    {
        JavaParser.genericTypeArgumentList_return retval = new JavaParser.genericTypeArgumentList_return();
        retval.start = input.LT(1);
        int genericTypeArgumentList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LESS_THAN185 = null;
        Token COMMA187 = null;
        JavaParser.genericTypeArgument_return genericTypeArgument186 = null;

        JavaParser.genericTypeArgument_return genericTypeArgument188 = null;

        JavaParser.genericTypeListClosing_return genericTypeListClosing189 = null;


        CommonTree LESS_THAN185_tree = null;
        CommonTree COMMA187_tree = null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleTokenStream stream_LESS_THAN = new RewriteRuleTokenStream(adaptor, "token LESS_THAN");
        RewriteRuleSubtreeStream stream_genericTypeArgument = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgument");
        RewriteRuleSubtreeStream stream_genericTypeListClosing = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeListClosing");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 50))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:697:5: ( LESS_THAN genericTypeArgument ( COMMA genericTypeArgument )* genericTypeListClosing -> ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgument )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:697:9: LESS_THAN genericTypeArgument ( COMMA genericTypeArgument )* genericTypeListClosing
            {
                LESS_THAN185 = (Token) match(input, LESS_THAN, FOLLOW_LESS_THAN_in_genericTypeArgumentList7224);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LESS_THAN.add(LESS_THAN185);

                pushFollow(FOLLOW_genericTypeArgument_in_genericTypeArgumentList7226);
                genericTypeArgument186 = genericTypeArgument();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_genericTypeArgument.add(genericTypeArgument186.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:697:39: ( COMMA genericTypeArgument )*
                loop66:
                do
                {
                    int alt66 = 2;
                    int LA66_0 = input.LA(1);

                    if ((LA66_0 == COMMA))
                    {
                        int LA66_2 = input.LA(2);

                        if ((synpred91_Java()))
                        {
                            alt66 = 1;
                        }


                    }


                    switch (alt66)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:697:40: COMMA genericTypeArgument
                        {
                            COMMA187 = (Token) match(input, COMMA, FOLLOW_COMMA_in_genericTypeArgumentList7229);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COMMA.add(COMMA187);

                            pushFollow(FOLLOW_genericTypeArgument_in_genericTypeArgumentList7231);
                            genericTypeArgument188 = genericTypeArgument();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_genericTypeArgument.add(genericTypeArgument188.getTree());

                        }
                        break;

                        default:
                            break loop66;
                    }
                }
                while (true);

                pushFollow(FOLLOW_genericTypeListClosing_in_genericTypeArgumentList7235);
                genericTypeListClosing189 = genericTypeListClosing();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_genericTypeListClosing.add(genericTypeListClosing189.getTree());


                // AST REWRITE
                // elements: genericTypeArgument
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 698:9: -> ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgument )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:698:13: ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgument )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(GENERIC_TYPE_ARG_LIST, LESS_THAN185, "GENERIC_TYPE_ARG_LIST"), root_1);

                            if (!(stream_genericTypeArgument.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_genericTypeArgument.hasNext())
                            {
                                adaptor.addChild(root_1, stream_genericTypeArgument.nextTree());

                            }
                            stream_genericTypeArgument.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 50, genericTypeArgumentList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeArgumentList"

    public static class genericTypeArgument_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeArgument"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:701:1: genericTypeArgument : ( type | QUESTION ( genericWildcardBoundType )? -> ^( QUESTION ( genericWildcardBoundType )? ) );

    public final JavaParser.genericTypeArgument_return genericTypeArgument() throws RecognitionException
    {
        JavaParser.genericTypeArgument_return retval = new JavaParser.genericTypeArgument_return();
        retval.start = input.LT(1);
        int genericTypeArgument_StartIndex = input.index();
        CommonTree root_0 = null;

        Token QUESTION191 = null;
        JavaParser.type_return type190 = null;

        JavaParser.genericWildcardBoundType_return genericWildcardBoundType192 = null;


        CommonTree QUESTION191_tree = null;
        RewriteRuleTokenStream stream_QUESTION = new RewriteRuleTokenStream(adaptor, "token QUESTION");
        RewriteRuleSubtreeStream stream_genericWildcardBoundType = new RewriteRuleSubtreeStream(adaptor, "rule genericWildcardBoundType");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 51))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:702:5: ( type | QUESTION ( genericWildcardBoundType )? -> ^( QUESTION ( genericWildcardBoundType )? ) )
            int alt68 = 2;
            int LA68_0 = input.LA(1);

            if ((LA68_0 == BOOLEAN || LA68_0 == BYTE || LA68_0 == CHAR || LA68_0 == DOUBLE || LA68_0 == FLOAT || (LA68_0 >= INT && LA68_0 <= LONG) || LA68_0 == SHORT || LA68_0 == IDENT))
            {
                alt68 = 1;
            }
            else if ((LA68_0 == QUESTION))
            {
                alt68 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 68, 0, input);

                throw nvae;
            }
            switch (alt68)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:702:9: type
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_type_in_genericTypeArgument7273);
                    type190 = type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, type190.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:703:9: QUESTION ( genericWildcardBoundType )?
                {
                    QUESTION191 = (Token) match(input, QUESTION, FOLLOW_QUESTION_in_genericTypeArgument7283);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_QUESTION.add(QUESTION191);

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:703:18: ( genericWildcardBoundType )?
                    int alt67 = 2;
                    int LA67_0 = input.LA(1);

                    if ((LA67_0 == EXTENDS))
                    {
                        int LA67_1 = input.LA(2);

                        if ((LA67_1 == BOOLEAN || LA67_1 == BYTE || LA67_1 == CHAR || LA67_1 == DOUBLE || LA67_1 == FLOAT || (LA67_1 >= INT && LA67_1 <= LONG) || LA67_1 == SHORT))
                        {
                            int LA67_4 = input.LA(3);

                            if ((synpred93_Java()))
                            {
                                alt67 = 1;
                            }
                        }
                        else if ((LA67_1 == IDENT))
                        {
                            int LA67_5 = input.LA(3);

                            if ((synpred93_Java()))
                            {
                                alt67 = 1;
                            }
                        }
                    }
                    else if ((LA67_0 == SUPER))
                    {
                        int LA67_3 = input.LA(2);

                        if ((LA67_3 == BOOLEAN || LA67_3 == BYTE || LA67_3 == CHAR || LA67_3 == DOUBLE || LA67_3 == FLOAT || (LA67_3 >= INT && LA67_3 <= LONG) || LA67_3 == SHORT || LA67_3 == IDENT))
                        {
                            alt67 = 1;
                        }
                    }
                    switch (alt67)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericWildcardBoundType
                        {
                            pushFollow(FOLLOW_genericWildcardBoundType_in_genericTypeArgument7285);
                            genericWildcardBoundType192 = genericWildcardBoundType();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_genericWildcardBoundType.add(genericWildcardBoundType192.getTree());

                        }
                        break;

                    }


                    // AST REWRITE
                    // elements: genericWildcardBoundType, QUESTION
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 704:9: -> ^( QUESTION ( genericWildcardBoundType )? )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:704:13: ^( QUESTION ( genericWildcardBoundType )? )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_QUESTION.nextNode(), root_1);

                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:704:24: ( genericWildcardBoundType )?
                                if (stream_genericWildcardBoundType.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_genericWildcardBoundType.nextTree());

                                }
                                stream_genericWildcardBoundType.reset();

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 51, genericTypeArgument_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeArgument"

    public static class genericWildcardBoundType_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericWildcardBoundType"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:707:1: genericWildcardBoundType : ( EXTENDS | SUPER ) type ;

    public final JavaParser.genericWildcardBoundType_return genericWildcardBoundType() throws RecognitionException
    {
        JavaParser.genericWildcardBoundType_return retval = new JavaParser.genericWildcardBoundType_return();
        retval.start = input.LT(1);
        int genericWildcardBoundType_StartIndex = input.index();
        CommonTree root_0 = null;

        Token set193 = null;
        JavaParser.type_return type194 = null;


        CommonTree set193_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 52))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:708:5: ( ( EXTENDS | SUPER ) type )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:708:9: ( EXTENDS | SUPER ) type
            {
                root_0 = (CommonTree) adaptor.nil();

                set193 = (Token) input.LT(1);
                set193 = (Token) input.LT(1);
                if (input.LA(1) == EXTENDS || input.LA(1) == SUPER)
                {
                    input.consume();
                    if (state.backtracking == 0)
                        root_0 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(set193), root_0);
                    state.errorRecovery = false;
                    state.failed = false;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    MismatchedSetException mse = new MismatchedSetException(null, input);
                    throw mse;
                }

                pushFollow(FOLLOW_type_in_genericWildcardBoundType7332);
                type194 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, type194.getTree());

            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 52, genericWildcardBoundType_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericWildcardBoundType"

    public static class genericTypeArgumentListSimplified_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeArgumentListSimplified"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:711:1: genericTypeArgumentListSimplified : LESS_THAN genericTypeArgumentSimplified ( COMMA genericTypeArgumentSimplified )* genericTypeListClosing -> ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgumentSimplified )+ ) ;

    public final JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified() throws RecognitionException
    {
        JavaParser.genericTypeArgumentListSimplified_return retval = new JavaParser.genericTypeArgumentListSimplified_return();
        retval.start = input.LT(1);
        int genericTypeArgumentListSimplified_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LESS_THAN195 = null;
        Token COMMA197 = null;
        JavaParser.genericTypeArgumentSimplified_return genericTypeArgumentSimplified196 = null;

        JavaParser.genericTypeArgumentSimplified_return genericTypeArgumentSimplified198 = null;

        JavaParser.genericTypeListClosing_return genericTypeListClosing199 = null;


        CommonTree LESS_THAN195_tree = null;
        CommonTree COMMA197_tree = null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleTokenStream stream_LESS_THAN = new RewriteRuleTokenStream(adaptor, "token LESS_THAN");
        RewriteRuleSubtreeStream stream_genericTypeArgumentSimplified = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgumentSimplified");
        RewriteRuleSubtreeStream stream_genericTypeListClosing = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeListClosing");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 53))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:712:5: ( LESS_THAN genericTypeArgumentSimplified ( COMMA genericTypeArgumentSimplified )* genericTypeListClosing -> ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgumentSimplified )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:712:9: LESS_THAN genericTypeArgumentSimplified ( COMMA genericTypeArgumentSimplified )* genericTypeListClosing
            {
                LESS_THAN195 = (Token) match(input, LESS_THAN, FOLLOW_LESS_THAN_in_genericTypeArgumentListSimplified7351);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LESS_THAN.add(LESS_THAN195);

                pushFollow(FOLLOW_genericTypeArgumentSimplified_in_genericTypeArgumentListSimplified7353);
                genericTypeArgumentSimplified196 = genericTypeArgumentSimplified();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0)
                    stream_genericTypeArgumentSimplified.add(genericTypeArgumentSimplified196.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:712:49: ( COMMA genericTypeArgumentSimplified )*
                loop69:
                do
                {
                    int alt69 = 2;
                    int LA69_0 = input.LA(1);

                    if ((LA69_0 == COMMA))
                    {
                        alt69 = 1;
                    }


                    switch (alt69)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:712:50: COMMA genericTypeArgumentSimplified
                        {
                            COMMA197 = (Token) match(input, COMMA, FOLLOW_COMMA_in_genericTypeArgumentListSimplified7356);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COMMA.add(COMMA197);

                            pushFollow(FOLLOW_genericTypeArgumentSimplified_in_genericTypeArgumentListSimplified7358);
                            genericTypeArgumentSimplified198 = genericTypeArgumentSimplified();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_genericTypeArgumentSimplified.add(genericTypeArgumentSimplified198.getTree());

                        }
                        break;

                        default:
                            break loop69;
                    }
                }
                while (true);

                pushFollow(FOLLOW_genericTypeListClosing_in_genericTypeArgumentListSimplified7362);
                genericTypeListClosing199 = genericTypeListClosing();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_genericTypeListClosing.add(genericTypeListClosing199.getTree());


                // AST REWRITE
                // elements: genericTypeArgumentSimplified
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 713:9: -> ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgumentSimplified )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:713:13: ^( GENERIC_TYPE_ARG_LIST[$LESS_THAN, \"GENERIC_TYPE_ARG_LIST\"] ( genericTypeArgumentSimplified )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(GENERIC_TYPE_ARG_LIST, LESS_THAN195, "GENERIC_TYPE_ARG_LIST"), root_1);

                            if (!(stream_genericTypeArgumentSimplified.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_genericTypeArgumentSimplified.hasNext())
                            {
                                adaptor.addChild(root_1, stream_genericTypeArgumentSimplified.nextTree());

                            }
                            stream_genericTypeArgumentSimplified.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 53, genericTypeArgumentListSimplified_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeArgumentListSimplified"

    public static class genericTypeArgumentSimplified_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "genericTypeArgumentSimplified"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:716:1: genericTypeArgumentSimplified : ( type | QUESTION );

    public final JavaParser.genericTypeArgumentSimplified_return genericTypeArgumentSimplified() throws RecognitionException
    {
        JavaParser.genericTypeArgumentSimplified_return retval = new JavaParser.genericTypeArgumentSimplified_return();
        retval.start = input.LT(1);
        int genericTypeArgumentSimplified_StartIndex = input.index();
        CommonTree root_0 = null;

        Token QUESTION201 = null;
        JavaParser.type_return type200 = null;


        CommonTree QUESTION201_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 54))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:717:5: ( type | QUESTION )
            int alt70 = 2;
            int LA70_0 = input.LA(1);

            if ((LA70_0 == BOOLEAN || LA70_0 == BYTE || LA70_0 == CHAR || LA70_0 == DOUBLE || LA70_0 == FLOAT || (LA70_0 >= INT && LA70_0 <= LONG) || LA70_0 == SHORT || LA70_0 == IDENT))
            {
                alt70 = 1;
            }
            else if ((LA70_0 == QUESTION))
            {
                alt70 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 70, 0, input);

                throw nvae;
            }
            switch (alt70)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:717:9: type
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_type_in_genericTypeArgumentSimplified7400);
                    type200 = type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, type200.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:718:9: QUESTION
                {
                    root_0 = (CommonTree) adaptor.nil();

                    QUESTION201 = (Token) match(input, QUESTION, FOLLOW_QUESTION_in_genericTypeArgumentSimplified7410);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        QUESTION201_tree = (CommonTree) adaptor.create(QUESTION201);
                        adaptor.addChild(root_0, QUESTION201_tree);
                    }

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 54, genericTypeArgumentSimplified_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "genericTypeArgumentSimplified"

    public static class qualifiedIdentList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "qualifiedIdentList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:721:1: qualifiedIdentList : qualifiedIdentifier ( COMMA qualifiedIdentifier )* ;

    public final JavaParser.qualifiedIdentList_return qualifiedIdentList() throws RecognitionException
    {
        JavaParser.qualifiedIdentList_return retval = new JavaParser.qualifiedIdentList_return();
        retval.start = input.LT(1);
        int qualifiedIdentList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA203 = null;
        JavaParser.qualifiedIdentifier_return qualifiedIdentifier202 = null;

        JavaParser.qualifiedIdentifier_return qualifiedIdentifier204 = null;


        CommonTree COMMA203_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 55))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:722:5: ( qualifiedIdentifier ( COMMA qualifiedIdentifier )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:722:9: qualifiedIdentifier ( COMMA qualifiedIdentifier )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_qualifiedIdentifier_in_qualifiedIdentList7429);
                qualifiedIdentifier202 = qualifiedIdentifier();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, qualifiedIdentifier202.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:722:29: ( COMMA qualifiedIdentifier )*
                loop71:
                do
                {
                    int alt71 = 2;
                    int LA71_0 = input.LA(1);

                    if ((LA71_0 == COMMA))
                    {
                        alt71 = 1;
                    }


                    switch (alt71)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:722:30: COMMA qualifiedIdentifier
                        {
                            COMMA203 = (Token) match(input, COMMA, FOLLOW_COMMA_in_qualifiedIdentList7432);
                            if (state.failed) return retval;
                            pushFollow(FOLLOW_qualifiedIdentifier_in_qualifiedIdentList7435);
                            qualifiedIdentifier204 = qualifiedIdentifier();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, qualifiedIdentifier204.getTree());

                        }
                        break;

                        default:
                            break loop71;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 55, qualifiedIdentList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "qualifiedIdentList"

    public static class formalParameterList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "formalParameterList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:725:1: formalParameterList : LPAREN ( formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )? -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ( formalParameterStandardDecl )+ ( formalParameterVarArgDecl )? ) | formalParameterVarArgDecl -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] formalParameterVarArgDecl ) | -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ) ) RPAREN ;

    public final JavaParser.formalParameterList_return formalParameterList() throws RecognitionException
    {
        JavaParser.formalParameterList_return retval = new JavaParser.formalParameterList_return();
        retval.start = input.LT(1);
        int formalParameterList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LPAREN205 = null;
        Token COMMA207 = null;
        Token COMMA209 = null;
        Token RPAREN212 = null;
        JavaParser.formalParameterStandardDecl_return formalParameterStandardDecl206 = null;

        JavaParser.formalParameterStandardDecl_return formalParameterStandardDecl208 = null;

        JavaParser.formalParameterVarArgDecl_return formalParameterVarArgDecl210 = null;

        JavaParser.formalParameterVarArgDecl_return formalParameterVarArgDecl211 = null;


        CommonTree LPAREN205_tree = null;
        CommonTree COMMA207_tree = null;
        CommonTree COMMA209_tree = null;
        CommonTree RPAREN212_tree = null;
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleSubtreeStream stream_formalParameterVarArgDecl = new RewriteRuleSubtreeStream(adaptor, "rule formalParameterVarArgDecl");
        RewriteRuleSubtreeStream stream_formalParameterStandardDecl = new RewriteRuleSubtreeStream(adaptor, "rule formalParameterStandardDecl");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 56))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:726:5: ( LPAREN ( formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )? -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ( formalParameterStandardDecl )+ ( formalParameterVarArgDecl )? ) | formalParameterVarArgDecl -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] formalParameterVarArgDecl ) | -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ) ) RPAREN )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:726:9: LPAREN ( formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )? -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ( formalParameterStandardDecl )+ ( formalParameterVarArgDecl )? ) | formalParameterVarArgDecl -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] formalParameterVarArgDecl ) | -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ) ) RPAREN
            {
                LPAREN205 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_formalParameterList7456);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LPAREN.add(LPAREN205);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:727:9: ( formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )? -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ( formalParameterStandardDecl )+ ( formalParameterVarArgDecl )? ) | formalParameterVarArgDecl -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] formalParameterVarArgDecl ) | -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ) )
                int alt74 = 3;
                switch (input.LA(1))
                {
                    case FINAL:
                    {
                        int LA74_1 = input.LA(2);

                        if ((synpred100_Java()))
                        {
                            alt74 = 1;
                        }
                        else if ((synpred101_Java()))
                        {
                            alt74 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 74, 1, input);

                            throw nvae;
                        }
                    }
                    break;
                    case AT:
                    {
                        int LA74_2 = input.LA(2);

                        if ((synpred100_Java()))
                        {
                            alt74 = 1;
                        }
                        else if ((synpred101_Java()))
                        {
                            alt74 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 74, 2, input);

                            throw nvae;
                        }
                    }
                    break;
                    case BOOLEAN:
                    case BYTE:
                    case CHAR:
                    case DOUBLE:
                    case FLOAT:
                    case INT:
                    case LONG:
                    case SHORT:
                    {
                        int LA74_3 = input.LA(2);

                        if ((synpred100_Java()))
                        {
                            alt74 = 1;
                        }
                        else if ((synpred101_Java()))
                        {
                            alt74 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 74, 3, input);

                            throw nvae;
                        }
                    }
                    break;
                    case IDENT:
                    {
                        int LA74_4 = input.LA(2);

                        if ((synpred100_Java()))
                        {
                            alt74 = 1;
                        }
                        else if ((synpred101_Java()))
                        {
                            alt74 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 74, 4, input);

                            throw nvae;
                        }
                    }
                    break;
                    case RPAREN:
                    {
                        alt74 = 3;
                    }
                    break;
                    default:
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 74, 0, input);

                        throw nvae;
                }

                switch (alt74)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:13: formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )?
                    {
                        pushFollow(FOLLOW_formalParameterStandardDecl_in_formalParameterList7483);
                        formalParameterStandardDecl206 = formalParameterStandardDecl();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_formalParameterStandardDecl.add(formalParameterStandardDecl206.getTree());
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:41: ( COMMA formalParameterStandardDecl )*
                        loop72:
                        do
                        {
                            int alt72 = 2;
                            int LA72_0 = input.LA(1);

                            if ((LA72_0 == COMMA))
                            {
                                int LA72_1 = input.LA(2);

                                if ((synpred98_Java()))
                                {
                                    alt72 = 1;
                                }


                            }


                            switch (alt72)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:42: COMMA formalParameterStandardDecl
                                {
                                    COMMA207 = (Token) match(input, COMMA, FOLLOW_COMMA_in_formalParameterList7486);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_COMMA.add(COMMA207);

                                    pushFollow(FOLLOW_formalParameterStandardDecl_in_formalParameterList7488);
                                    formalParameterStandardDecl208 = formalParameterStandardDecl();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_formalParameterStandardDecl.add(formalParameterStandardDecl208.getTree());

                                }
                                break;

                                default:
                                    break loop72;
                            }
                        }
                        while (true);

                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:78: ( COMMA formalParameterVarArgDecl )?
                        int alt73 = 2;
                        int LA73_0 = input.LA(1);

                        if ((LA73_0 == COMMA))
                        {
                            alt73 = 1;
                        }
                        switch (alt73)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:79: COMMA formalParameterVarArgDecl
                            {
                                COMMA209 = (Token) match(input, COMMA, FOLLOW_COMMA_in_formalParameterList7493);
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_COMMA.add(COMMA209);

                                pushFollow(FOLLOW_formalParameterVarArgDecl_in_formalParameterList7495);
                                formalParameterVarArgDecl210 = formalParameterVarArgDecl();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                    stream_formalParameterVarArgDecl.add(formalParameterVarArgDecl210.getTree());

                            }
                            break;

                        }


                        // AST REWRITE
                        // elements: formalParameterStandardDecl, formalParameterVarArgDecl
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 729:13: -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ( formalParameterStandardDecl )+ ( formalParameterVarArgDecl )? )
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:729:17: ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] ( formalParameterStandardDecl )+ ( formalParameterVarArgDecl )? )
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FORMAL_PARAM_LIST, LPAREN205, "FORMAL_PARAM_LIST"), root_1);

                                    if (!(stream_formalParameterStandardDecl.hasNext()))
                                    {
                                        throw new RewriteEarlyExitException();
                                    }
                                    while (stream_formalParameterStandardDecl.hasNext())
                                    {
                                        adaptor.addChild(root_1, stream_formalParameterStandardDecl.nextTree());

                                    }
                                    stream_formalParameterStandardDecl.reset();
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:729:96: ( formalParameterVarArgDecl )?
                                    if (stream_formalParameterVarArgDecl.hasNext())
                                    {
                                        adaptor.addChild(root_1, stream_formalParameterVarArgDecl.nextTree());

                                    }
                                    stream_formalParameterVarArgDecl.reset();

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;
                    case 2:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:731:13: formalParameterVarArgDecl
                    {
                        pushFollow(FOLLOW_formalParameterVarArgDecl_in_formalParameterList7550);
                        formalParameterVarArgDecl211 = formalParameterVarArgDecl();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_formalParameterVarArgDecl.add(formalParameterVarArgDecl211.getTree());


                        // AST REWRITE
                        // elements: formalParameterVarArgDecl
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 732:13: -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] formalParameterVarArgDecl )
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:732:17: ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] formalParameterVarArgDecl )
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FORMAL_PARAM_LIST, LPAREN205, "FORMAL_PARAM_LIST"), root_1);

                                    adaptor.addChild(root_1, stream_formalParameterVarArgDecl.nextTree());

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;
                    case 3:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:734:13:
                    {

                        // AST REWRITE
                        // elements:
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 734:13: -> ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] )
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:734:17: ^( FORMAL_PARAM_LIST[$LPAREN, \"FORMAL_PARAM_LIST\"] )
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FORMAL_PARAM_LIST, LPAREN205, "FORMAL_PARAM_LIST"), root_1);

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;

                }

                RPAREN212 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_formalParameterList7625);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RPAREN.add(RPAREN212);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 56, formalParameterList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "formalParameterList"

    public static class formalParameterStandardDecl_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "formalParameterStandardDecl"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:739:1: formalParameterStandardDecl : localModifierList type variableDeclaratorId -> ^( FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId ) ;

    public final JavaParser.formalParameterStandardDecl_return formalParameterStandardDecl() throws RecognitionException
    {
        JavaParser.formalParameterStandardDecl_return retval = new JavaParser.formalParameterStandardDecl_return();
        retval.start = input.LT(1);
        int formalParameterStandardDecl_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.localModifierList_return localModifierList213 = null;

        JavaParser.type_return type214 = null;

        JavaParser.variableDeclaratorId_return variableDeclaratorId215 = null;


        RewriteRuleSubtreeStream stream_variableDeclaratorId = new RewriteRuleSubtreeStream(adaptor, "rule variableDeclaratorId");
        RewriteRuleSubtreeStream stream_localModifierList = new RewriteRuleSubtreeStream(adaptor, "rule localModifierList");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 57))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:740:5: ( localModifierList type variableDeclaratorId -> ^( FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:740:9: localModifierList type variableDeclaratorId
            {
                pushFollow(FOLLOW_localModifierList_in_formalParameterStandardDecl7644);
                localModifierList213 = localModifierList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_localModifierList.add(localModifierList213.getTree());
                pushFollow(FOLLOW_type_in_formalParameterStandardDecl7646);
                type214 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_type.add(type214.getTree());
                pushFollow(FOLLOW_variableDeclaratorId_in_formalParameterStandardDecl7648);
                variableDeclaratorId215 = variableDeclaratorId();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_variableDeclaratorId.add(variableDeclaratorId215.getTree());


                // AST REWRITE
                // elements: localModifierList, variableDeclaratorId, type
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 741:9: -> ^( FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:741:13: ^( FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FORMAL_PARAM_STD_DECL, "FORMAL_PARAM_STD_DECL"), root_1);

                            adaptor.addChild(root_1, stream_localModifierList.nextTree());
                            adaptor.addChild(root_1, stream_type.nextTree());
                            adaptor.addChild(root_1, stream_variableDeclaratorId.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 57, formalParameterStandardDecl_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "formalParameterStandardDecl"

    public static class formalParameterVarArgDecl_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "formalParameterVarArgDecl"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:744:1: formalParameterVarArgDecl : localModifierList type ELLIPSIS variableDeclaratorId -> ^( FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId ) ;

    public final JavaParser.formalParameterVarArgDecl_return formalParameterVarArgDecl() throws RecognitionException
    {
        JavaParser.formalParameterVarArgDecl_return retval = new JavaParser.formalParameterVarArgDecl_return();
        retval.start = input.LT(1);
        int formalParameterVarArgDecl_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ELLIPSIS218 = null;
        JavaParser.localModifierList_return localModifierList216 = null;

        JavaParser.type_return type217 = null;

        JavaParser.variableDeclaratorId_return variableDeclaratorId219 = null;


        CommonTree ELLIPSIS218_tree = null;
        RewriteRuleTokenStream stream_ELLIPSIS = new RewriteRuleTokenStream(adaptor, "token ELLIPSIS");
        RewriteRuleSubtreeStream stream_variableDeclaratorId = new RewriteRuleSubtreeStream(adaptor, "rule variableDeclaratorId");
        RewriteRuleSubtreeStream stream_localModifierList = new RewriteRuleSubtreeStream(adaptor, "rule localModifierList");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 58))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:745:5: ( localModifierList type ELLIPSIS variableDeclaratorId -> ^( FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:745:9: localModifierList type ELLIPSIS variableDeclaratorId
            {
                pushFollow(FOLLOW_localModifierList_in_formalParameterVarArgDecl7688);
                localModifierList216 = localModifierList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_localModifierList.add(localModifierList216.getTree());
                pushFollow(FOLLOW_type_in_formalParameterVarArgDecl7690);
                type217 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_type.add(type217.getTree());
                ELLIPSIS218 = (Token) match(input, ELLIPSIS, FOLLOW_ELLIPSIS_in_formalParameterVarArgDecl7692);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_ELLIPSIS.add(ELLIPSIS218);

                pushFollow(FOLLOW_variableDeclaratorId_in_formalParameterVarArgDecl7694);
                variableDeclaratorId219 = variableDeclaratorId();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_variableDeclaratorId.add(variableDeclaratorId219.getTree());


                // AST REWRITE
                // elements: variableDeclaratorId, type, localModifierList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 746:9: -> ^( FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:746:13: ^( FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FORMAL_PARAM_VARARG_DECL, "FORMAL_PARAM_VARARG_DECL"), root_1);

                            adaptor.addChild(root_1, stream_localModifierList.nextTree());
                            adaptor.addChild(root_1, stream_type.nextTree());
                            adaptor.addChild(root_1, stream_variableDeclaratorId.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 58, formalParameterVarArgDecl_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "formalParameterVarArgDecl"

    public static class qualifiedIdentifier_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "qualifiedIdentifier"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:749:1: qualifiedIdentifier : ( IDENT -> IDENT ) ( DOT ident= IDENT -> ^( DOT $qualifiedIdentifier $ident) )* ;

    public final JavaParser.qualifiedIdentifier_return qualifiedIdentifier() throws RecognitionException
    {
        JavaParser.qualifiedIdentifier_return retval = new JavaParser.qualifiedIdentifier_return();
        retval.start = input.LT(1);
        int qualifiedIdentifier_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ident = null;
        Token IDENT220 = null;
        Token DOT221 = null;

        CommonTree ident_tree = null;
        CommonTree IDENT220_tree = null;
        CommonTree DOT221_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor, "token DOT");

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 59))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:750:5: ( ( IDENT -> IDENT ) ( DOT ident= IDENT -> ^( DOT $qualifiedIdentifier $ident) )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:750:9: ( IDENT -> IDENT ) ( DOT ident= IDENT -> ^( DOT $qualifiedIdentifier $ident) )*
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:750:9: ( IDENT -> IDENT )
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:750:13: IDENT
                {
                    IDENT220 = (Token) match(input, IDENT, FOLLOW_IDENT_in_qualifiedIdentifier7738);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_IDENT.add(IDENT220);


                    // AST REWRITE
                    // elements: IDENT
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 750:33: -> IDENT
                        {
                            adaptor.addChild(root_0, stream_IDENT.nextNode());

                        }

                        retval.tree = root_0;
                    }
                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:752:9: ( DOT ident= IDENT -> ^( DOT $qualifiedIdentifier $ident) )*
                loop75:
                do
                {
                    int alt75 = 2;
                    int LA75_0 = input.LA(1);

                    if ((LA75_0 == DOT))
                    {
                        int LA75_2 = input.LA(2);

                        if ((LA75_2 == IDENT))
                        {
                            int LA75_3 = input.LA(3);

                            if ((synpred102_Java()))
                            {
                                alt75 = 1;
                            }


                        }


                    }


                    switch (alt75)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:752:13: DOT ident= IDENT
                        {
                            DOT221 = (Token) match(input, DOT, FOLLOW_DOT_in_qualifiedIdentifier7781);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_DOT.add(DOT221);

                            ident = (Token) match(input, IDENT, FOLLOW_IDENT_in_qualifiedIdentifier7785);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_IDENT.add(ident);


                            // AST REWRITE
                            // elements: qualifiedIdentifier, DOT, ident
                            // token labels: ident
                            // rule labels: retval
                            // token list labels:
                            // rule list labels:
                            // wildcard labels:
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleTokenStream stream_ident = new RewriteRuleTokenStream(adaptor, "token ident", ident);
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 752:33: -> ^( DOT $qualifiedIdentifier $ident)
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:752:37: ^( DOT $qualifiedIdentifier $ident)
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_retval.nextTree());
                                        adaptor.addChild(root_1, stream_ident.nextNode());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                        default:
                            break loop75;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 59, qualifiedIdentifier_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "qualifiedIdentifier"

    public static class annotationList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:758:1: annotationList : ( annotation )* -> ^( ANNOTATION_LIST ( annotation )* ) ;

    public final JavaParser.annotationList_return annotationList() throws RecognitionException
    {
        JavaParser.annotationList_return retval = new JavaParser.annotationList_return();
        retval.start = input.LT(1);
        int annotationList_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.annotation_return annotation222 = null;


        RewriteRuleSubtreeStream stream_annotation = new RewriteRuleSubtreeStream(adaptor, "rule annotation");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 60))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:759:5: ( ( annotation )* -> ^( ANNOTATION_LIST ( annotation )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:759:9: ( annotation )*
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:759:9: ( annotation )*
                loop76:
                do
                {
                    int alt76 = 2;
                    int LA76_0 = input.LA(1);

                    if ((LA76_0 == AT))
                    {
                        int LA76_2 = input.LA(2);

                        if ((LA76_2 == IDENT))
                        {
                            int LA76_3 = input.LA(3);

                            if ((synpred103_Java()))
                            {
                                alt76 = 1;
                            }


                        }


                    }


                    switch (alt76)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: annotation
                        {
                            pushFollow(FOLLOW_annotation_in_annotationList7834);
                            annotation222 = annotation();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_annotation.add(annotation222.getTree());

                        }
                        break;

                        default:
                            break loop76;
                    }
                }
                while (true);


                // AST REWRITE
                // elements: annotation
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 760:9: -> ^( ANNOTATION_LIST ( annotation )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:760:13: ^( ANNOTATION_LIST ( annotation )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_LIST, "ANNOTATION_LIST"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:760:31: ( annotation )*
                            while (stream_annotation.hasNext())
                            {
                                adaptor.addChild(root_1, stream_annotation.nextTree());

                            }
                            stream_annotation.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 60, annotationList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationList"

    public static class annotation_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotation"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:763:1: annotation : AT qualifiedIdentifier ( annotationInit )? ;

    public final JavaParser.annotation_return annotation() throws RecognitionException
    {
        JavaParser.annotation_return retval = new JavaParser.annotation_return();
        retval.start = input.LT(1);
        int annotation_StartIndex = input.index();
        CommonTree root_0 = null;

        Token AT223 = null;
        JavaParser.qualifiedIdentifier_return qualifiedIdentifier224 = null;

        JavaParser.annotationInit_return annotationInit225 = null;


        CommonTree AT223_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 61))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:764:5: ( AT qualifiedIdentifier ( annotationInit )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:764:9: AT qualifiedIdentifier ( annotationInit )?
            {
                root_0 = (CommonTree) adaptor.nil();

                AT223 = (Token) match(input, AT, FOLLOW_AT_in_annotation7872);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    AT223_tree = (CommonTree) adaptor.create(AT223);
                    root_0 = (CommonTree) adaptor.becomeRoot(AT223_tree, root_0);
                }
                pushFollow(FOLLOW_qualifiedIdentifier_in_annotation7875);
                qualifiedIdentifier224 = qualifiedIdentifier();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, qualifiedIdentifier224.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:764:33: ( annotationInit )?
                int alt77 = 2;
                int LA77_0 = input.LA(1);

                if ((LA77_0 == LPAREN))
                {
                    alt77 = 1;
                }
                switch (alt77)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: annotationInit
                    {
                        pushFollow(FOLLOW_annotationInit_in_annotation7877);
                        annotationInit225 = annotationInit();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, annotationInit225.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 61, annotation_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotation"

    public static class annotationInit_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationInit"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:767:1: annotationInit : LPAREN annotationInitializers RPAREN -> ^( ANNOTATION_INIT_BLOCK[$LPAREN, \"ANNOTATION_INIT_BLOCK\"] annotationInitializers ) ;

    public final JavaParser.annotationInit_return annotationInit() throws RecognitionException
    {
        JavaParser.annotationInit_return retval = new JavaParser.annotationInit_return();
        retval.start = input.LT(1);
        int annotationInit_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LPAREN226 = null;
        Token RPAREN228 = null;
        JavaParser.annotationInitializers_return annotationInitializers227 = null;


        CommonTree LPAREN226_tree = null;
        CommonTree RPAREN228_tree = null;
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleSubtreeStream stream_annotationInitializers = new RewriteRuleSubtreeStream(adaptor, "rule annotationInitializers");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 62))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:768:5: ( LPAREN annotationInitializers RPAREN -> ^( ANNOTATION_INIT_BLOCK[$LPAREN, \"ANNOTATION_INIT_BLOCK\"] annotationInitializers ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:768:9: LPAREN annotationInitializers RPAREN
            {
                LPAREN226 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_annotationInit7897);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LPAREN.add(LPAREN226);

                pushFollow(FOLLOW_annotationInitializers_in_annotationInit7899);
                annotationInitializers227 = annotationInitializers();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_annotationInitializers.add(annotationInitializers227.getTree());
                RPAREN228 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_annotationInit7901);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RPAREN.add(RPAREN228);


                // AST REWRITE
                // elements: annotationInitializers
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 769:9: -> ^( ANNOTATION_INIT_BLOCK[$LPAREN, \"ANNOTATION_INIT_BLOCK\"] annotationInitializers )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:769:13: ^( ANNOTATION_INIT_BLOCK[$LPAREN, \"ANNOTATION_INIT_BLOCK\"] annotationInitializers )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_INIT_BLOCK, LPAREN226, "ANNOTATION_INIT_BLOCK"), root_1);

                            adaptor.addChild(root_1, stream_annotationInitializers.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 62, annotationInit_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationInit"

    public static class annotationInitializers_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationInitializers"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:772:1: annotationInitializers : ( annotationInitializer ( COMMA annotationInitializer )* -> ^( ANNOTATION_INIT_KEY_LIST ( annotationInitializer )+ ) | annotationElementValue -> ^( ANNOTATION_INIT_DEFAULT_KEY annotationElementValue ) );

    public final JavaParser.annotationInitializers_return annotationInitializers() throws RecognitionException
    {
        JavaParser.annotationInitializers_return retval = new JavaParser.annotationInitializers_return();
        retval.start = input.LT(1);
        int annotationInitializers_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA230 = null;
        JavaParser.annotationInitializer_return annotationInitializer229 = null;

        JavaParser.annotationInitializer_return annotationInitializer231 = null;

        JavaParser.annotationElementValue_return annotationElementValue232 = null;


        CommonTree COMMA230_tree = null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleSubtreeStream stream_annotationElementValue = new RewriteRuleSubtreeStream(adaptor, "rule annotationElementValue");
        RewriteRuleSubtreeStream stream_annotationInitializer = new RewriteRuleSubtreeStream(adaptor, "rule annotationInitializer");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 63))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:773:5: ( annotationInitializer ( COMMA annotationInitializer )* -> ^( ANNOTATION_INIT_KEY_LIST ( annotationInitializer )+ ) | annotationElementValue -> ^( ANNOTATION_INIT_DEFAULT_KEY annotationElementValue ) )
            int alt79 = 2;
            int LA79_0 = input.LA(1);

            if ((LA79_0 == IDENT))
            {
                int LA79_1 = input.LA(2);

                if ((LA79_1 == ASSIGN))
                {
                    alt79 = 1;
                }
                else if ((LA79_1 == AND || LA79_1 == BIT_SHIFT_RIGHT || (LA79_1 >= DEC && LA79_1 <= DIV) || LA79_1 == DOT || (LA79_1 >= EQUAL && LA79_1 <= LBRACK) || (LA79_1 >= LESS_OR_EQUAL && LA79_1 <= LOGICAL_AND) || (LA79_1 >= LOGICAL_OR && LA79_1 <= MINUS) || LA79_1 == MOD || (LA79_1 >= NOT_EQUAL && LA79_1 <= OR) || LA79_1 == PLUS || LA79_1 == QUESTION || LA79_1 == RPAREN || LA79_1 == SHIFT_LEFT || LA79_1 == SHIFT_RIGHT || LA79_1 == STAR || LA79_1 == XOR || LA79_1 == INSTANCEOF))
                {
                    alt79 = 2;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 79, 1, input);

                    throw nvae;
                }
            }
            else if ((LA79_0 == AT || LA79_0 == DEC || LA79_0 == INC || LA79_0 == LCURLY || LA79_0 == LESS_THAN || LA79_0 == LOGICAL_NOT || (LA79_0 >= LPAREN && LA79_0 <= MINUS) || LA79_0 == NOT || LA79_0 == PLUS || LA79_0 == BOOLEAN || LA79_0 == BYTE || LA79_0 == CHAR || LA79_0 == DOUBLE || LA79_0 == FALSE || LA79_0 == FLOAT || (LA79_0 >= INT && LA79_0 <= LONG) || (LA79_0 >= NEW && LA79_0 <= NULL) || LA79_0 == SHORT || LA79_0 == SUPER || LA79_0 == THIS || LA79_0 == TRUE || LA79_0 == VOID || (LA79_0 >= HEX_LITERAL && LA79_0 <= STRING_LITERAL)))
            {
                alt79 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 79, 0, input);

                throw nvae;
            }
            switch (alt79)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:773:9: annotationInitializer ( COMMA annotationInitializer )*
                {
                    pushFollow(FOLLOW_annotationInitializer_in_annotationInitializers7938);
                    annotationInitializer229 = annotationInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_annotationInitializer.add(annotationInitializer229.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:773:31: ( COMMA annotationInitializer )*
                    loop78:
                    do
                    {
                        int alt78 = 2;
                        int LA78_0 = input.LA(1);

                        if ((LA78_0 == COMMA))
                        {
                            alt78 = 1;
                        }


                        switch (alt78)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:773:32: COMMA annotationInitializer
                            {
                                COMMA230 = (Token) match(input, COMMA, FOLLOW_COMMA_in_annotationInitializers7941);
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_COMMA.add(COMMA230);

                                pushFollow(FOLLOW_annotationInitializer_in_annotationInitializers7943);
                                annotationInitializer231 = annotationInitializer();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                    stream_annotationInitializer.add(annotationInitializer231.getTree());

                            }
                            break;

                            default:
                                break loop78;
                        }
                    }
                    while (true);


                    // AST REWRITE
                    // elements: annotationInitializer
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 774:9: -> ^( ANNOTATION_INIT_KEY_LIST ( annotationInitializer )+ )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:774:13: ^( ANNOTATION_INIT_KEY_LIST ( annotationInitializer )+ )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_INIT_KEY_LIST, "ANNOTATION_INIT_KEY_LIST"), root_1);

                                if (!(stream_annotationInitializer.hasNext()))
                                {
                                    throw new RewriteEarlyExitException();
                                }
                                while (stream_annotationInitializer.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_annotationInitializer.nextTree());

                                }
                                stream_annotationInitializer.reset();

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:775:9: annotationElementValue
                {
                    pushFollow(FOLLOW_annotationElementValue_in_annotationInitializers7973);
                    annotationElementValue232 = annotationElementValue();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_annotationElementValue.add(annotationElementValue232.getTree());


                    // AST REWRITE
                    // elements: annotationElementValue
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 776:9: -> ^( ANNOTATION_INIT_DEFAULT_KEY annotationElementValue )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:776:13: ^( ANNOTATION_INIT_DEFAULT_KEY annotationElementValue )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_INIT_DEFAULT_KEY, "ANNOTATION_INIT_DEFAULT_KEY"), root_1);

                                adaptor.addChild(root_1, stream_annotationElementValue.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 63, annotationInitializers_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationInitializers"

    public static class annotationInitializer_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationInitializer"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:779:1: annotationInitializer : IDENT ASSIGN annotationElementValue ;

    public final JavaParser.annotationInitializer_return annotationInitializer() throws RecognitionException
    {
        JavaParser.annotationInitializer_return retval = new JavaParser.annotationInitializer_return();
        retval.start = input.LT(1);
        int annotationInitializer_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT233 = null;
        Token ASSIGN234 = null;
        JavaParser.annotationElementValue_return annotationElementValue235 = null;


        CommonTree IDENT233_tree = null;
        CommonTree ASSIGN234_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 64))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:780:5: ( IDENT ASSIGN annotationElementValue )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:780:9: IDENT ASSIGN annotationElementValue
            {
                root_0 = (CommonTree) adaptor.nil();

                IDENT233 = (Token) match(input, IDENT, FOLLOW_IDENT_in_annotationInitializer8010);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    IDENT233_tree = (CommonTree) adaptor.create(IDENT233);
                    root_0 = (CommonTree) adaptor.becomeRoot(IDENT233_tree, root_0);
                }
                ASSIGN234 = (Token) match(input, ASSIGN, FOLLOW_ASSIGN_in_annotationInitializer8013);
                if (state.failed) return retval;
                pushFollow(FOLLOW_annotationElementValue_in_annotationInitializer8016);
                annotationElementValue235 = annotationElementValue();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, annotationElementValue235.getTree());

            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 64, annotationInitializer_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationInitializer"

    public static class annotationElementValue_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationElementValue"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:783:1: annotationElementValue : ( annotationElementValueExpression | annotation | annotationElementValueArrayInitializer );

    public final JavaParser.annotationElementValue_return annotationElementValue() throws RecognitionException
    {
        JavaParser.annotationElementValue_return retval = new JavaParser.annotationElementValue_return();
        retval.start = input.LT(1);
        int annotationElementValue_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.annotationElementValueExpression_return annotationElementValueExpression236 = null;

        JavaParser.annotation_return annotation237 = null;

        JavaParser.annotationElementValueArrayInitializer_return annotationElementValueArrayInitializer238 = null;


        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 65))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:784:5: ( annotationElementValueExpression | annotation | annotationElementValueArrayInitializer )
            int alt80 = 3;
            switch (input.LA(1))
            {
                case DEC:
                case INC:
                case LESS_THAN:
                case LOGICAL_NOT:
                case LPAREN:
                case MINUS:
                case NOT:
                case PLUS:
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FALSE:
                case FLOAT:
                case INT:
                case LONG:
                case NEW:
                case NULL:
                case SHORT:
                case SUPER:
                case THIS:
                case TRUE:
                case VOID:
                case IDENT:
                case HEX_LITERAL:
                case OCTAL_LITERAL:
                case DECIMAL_LITERAL:
                case FLOATING_POINT_LITERAL:
                case CHARACTER_LITERAL:
                case STRING_LITERAL:
                {
                    alt80 = 1;
                }
                break;
                case AT:
                {
                    alt80 = 2;
                }
                break;
                case LCURLY:
                {
                    alt80 = 3;
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 80, 0, input);

                    throw nvae;
            }

            switch (alt80)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:784:9: annotationElementValueExpression
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_annotationElementValueExpression_in_annotationElementValue8035);
                    annotationElementValueExpression236 = annotationElementValueExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        adaptor.addChild(root_0, annotationElementValueExpression236.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:785:9: annotation
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_annotation_in_annotationElementValue8045);
                    annotation237 = annotation();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, annotation237.getTree());

                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:786:9: annotationElementValueArrayInitializer
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_annotationElementValueArrayInitializer_in_annotationElementValue8055);
                    annotationElementValueArrayInitializer238 = annotationElementValueArrayInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        adaptor.addChild(root_0, annotationElementValueArrayInitializer238.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 65, annotationElementValue_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationElementValue"

    public static class annotationElementValueExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationElementValueExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:789:1: annotationElementValueExpression : conditionalExpression -> ^( EXPR conditionalExpression ) ;

    public final JavaParser.annotationElementValueExpression_return annotationElementValueExpression() throws RecognitionException
    {
        JavaParser.annotationElementValueExpression_return retval = new JavaParser.annotationElementValueExpression_return();
        retval.start = input.LT(1);
        int annotationElementValueExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.conditionalExpression_return conditionalExpression239 = null;


        RewriteRuleSubtreeStream stream_conditionalExpression = new RewriteRuleSubtreeStream(adaptor, "rule conditionalExpression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 66))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:790:5: ( conditionalExpression -> ^( EXPR conditionalExpression ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:790:9: conditionalExpression
            {
                pushFollow(FOLLOW_conditionalExpression_in_annotationElementValueExpression8074);
                conditionalExpression239 = conditionalExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_conditionalExpression.add(conditionalExpression239.getTree());


                // AST REWRITE
                // elements: conditionalExpression
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 791:9: -> ^( EXPR conditionalExpression )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:791:13: ^( EXPR conditionalExpression )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(EXPR, "EXPR"), root_1);

                            adaptor.addChild(root_1, stream_conditionalExpression.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 66, annotationElementValueExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationElementValueExpression"

    public static class annotationElementValueArrayInitializer_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationElementValueArrayInitializer"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:794:1: annotationElementValueArrayInitializer : LCURLY ( annotationElementValue ( COMMA annotationElementValue )* )? ( COMMA )? RCURLY -> ^( ANNOTATION_INIT_ARRAY_ELEMENT[$LCURLY, \"ANNOTATION_ELEM_VALUE_ARRAY_INIT\"] ( annotationElementValue )* ) ;

    public final JavaParser.annotationElementValueArrayInitializer_return annotationElementValueArrayInitializer() throws RecognitionException
    {
        JavaParser.annotationElementValueArrayInitializer_return retval = new JavaParser.annotationElementValueArrayInitializer_return();
        retval.start = input.LT(1);
        int annotationElementValueArrayInitializer_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY240 = null;
        Token COMMA242 = null;
        Token COMMA244 = null;
        Token RCURLY245 = null;
        JavaParser.annotationElementValue_return annotationElementValue241 = null;

        JavaParser.annotationElementValue_return annotationElementValue243 = null;


        CommonTree LCURLY240_tree = null;
        CommonTree COMMA242_tree = null;
        CommonTree COMMA244_tree = null;
        CommonTree RCURLY245_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor, "token COMMA");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_annotationElementValue = new RewriteRuleSubtreeStream(adaptor, "rule annotationElementValue");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 67))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:5: ( LCURLY ( annotationElementValue ( COMMA annotationElementValue )* )? ( COMMA )? RCURLY -> ^( ANNOTATION_INIT_ARRAY_ELEMENT[$LCURLY, \"ANNOTATION_ELEM_VALUE_ARRAY_INIT\"] ( annotationElementValue )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:9: LCURLY ( annotationElementValue ( COMMA annotationElementValue )* )? ( COMMA )? RCURLY
            {
                LCURLY240 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_annotationElementValueArrayInitializer8110);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY240);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:16: ( annotationElementValue ( COMMA annotationElementValue )* )?
                int alt82 = 2;
                int LA82_0 = input.LA(1);

                if ((LA82_0 == AT || LA82_0 == DEC || LA82_0 == INC || LA82_0 == LCURLY || LA82_0 == LESS_THAN || LA82_0 == LOGICAL_NOT || (LA82_0 >= LPAREN && LA82_0 <= MINUS) || LA82_0 == NOT || LA82_0 == PLUS || LA82_0 == BOOLEAN || LA82_0 == BYTE || LA82_0 == CHAR || LA82_0 == DOUBLE || LA82_0 == FALSE || LA82_0 == FLOAT || (LA82_0 >= INT && LA82_0 <= LONG) || (LA82_0 >= NEW && LA82_0 <= NULL) || LA82_0 == SHORT || LA82_0 == SUPER || LA82_0 == THIS || LA82_0 == TRUE || LA82_0 == VOID || (LA82_0 >= IDENT && LA82_0 <= STRING_LITERAL)))
                {
                    alt82 = 1;
                }
                switch (alt82)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:17: annotationElementValue ( COMMA annotationElementValue )*
                    {
                        pushFollow(FOLLOW_annotationElementValue_in_annotationElementValueArrayInitializer8113);
                        annotationElementValue241 = annotationElementValue();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_annotationElementValue.add(annotationElementValue241.getTree());
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:40: ( COMMA annotationElementValue )*
                        loop81:
                        do
                        {
                            int alt81 = 2;
                            int LA81_0 = input.LA(1);

                            if ((LA81_0 == COMMA))
                            {
                                int LA81_1 = input.LA(2);

                                if ((LA81_1 == AT || LA81_1 == DEC || LA81_1 == INC || LA81_1 == LCURLY || LA81_1 == LESS_THAN || LA81_1 == LOGICAL_NOT || (LA81_1 >= LPAREN && LA81_1 <= MINUS) || LA81_1 == NOT || LA81_1 == PLUS || LA81_1 == BOOLEAN || LA81_1 == BYTE || LA81_1 == CHAR || LA81_1 == DOUBLE || LA81_1 == FALSE || LA81_1 == FLOAT || (LA81_1 >= INT && LA81_1 <= LONG) || (LA81_1 >= NEW && LA81_1 <= NULL) || LA81_1 == SHORT || LA81_1 == SUPER || LA81_1 == THIS || LA81_1 == TRUE || LA81_1 == VOID || (LA81_1 >= IDENT && LA81_1 <= STRING_LITERAL)))
                                {
                                    alt81 = 1;
                                }


                            }


                            switch (alt81)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:41: COMMA annotationElementValue
                                {
                                    COMMA242 = (Token) match(input, COMMA, FOLLOW_COMMA_in_annotationElementValueArrayInitializer8116);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_COMMA.add(COMMA242);

                                    pushFollow(FOLLOW_annotationElementValue_in_annotationElementValueArrayInitializer8118);
                                    annotationElementValue243 = annotationElementValue();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_annotationElementValue.add(annotationElementValue243.getTree());

                                }
                                break;

                                default:
                                    break loop81;
                            }
                        }
                        while (true);


                    }
                    break;

                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:74: ( COMMA )?
                int alt83 = 2;
                int LA83_0 = input.LA(1);

                if ((LA83_0 == COMMA))
                {
                    alt83 = 1;
                }
                switch (alt83)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:795:75: COMMA
                    {
                        COMMA244 = (Token) match(input, COMMA, FOLLOW_COMMA_in_annotationElementValueArrayInitializer8125);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_COMMA.add(COMMA244);


                    }
                    break;

                }

                RCURLY245 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_annotationElementValueArrayInitializer8129);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY245);


                // AST REWRITE
                // elements: annotationElementValue
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 796:9: -> ^( ANNOTATION_INIT_ARRAY_ELEMENT[$LCURLY, \"ANNOTATION_ELEM_VALUE_ARRAY_INIT\"] ( annotationElementValue )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:796:13: ^( ANNOTATION_INIT_ARRAY_ELEMENT[$LCURLY, \"ANNOTATION_ELEM_VALUE_ARRAY_INIT\"] ( annotationElementValue )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_INIT_ARRAY_ELEMENT, LCURLY240, "ANNOTATION_ELEM_VALUE_ARRAY_INIT"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:796:90: ( annotationElementValue )*
                            while (stream_annotationElementValue.hasNext())
                            {
                                adaptor.addChild(root_1, stream_annotationElementValue.nextTree());

                            }
                            stream_annotationElementValue.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 67, annotationElementValueArrayInitializer_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationElementValueArrayInitializer"

    public static class annotationTypeDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationTypeDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:799:1: annotationTypeDeclaration[CommonTree modifiers] : AT INTERFACE IDENT annotationBody -> ^( AT IDENT annotationBody ) ;

    public final JavaParser.annotationTypeDeclaration_return annotationTypeDeclaration(CommonTree modifiers) throws RecognitionException
    {
        JavaParser.annotationTypeDeclaration_return retval = new JavaParser.annotationTypeDeclaration_return();
        retval.start = input.LT(1);
        int annotationTypeDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        Token AT246 = null;
        Token INTERFACE247 = null;
        Token IDENT248 = null;
        JavaParser.annotationBody_return annotationBody249 = null;


        CommonTree AT246_tree = null;
        CommonTree INTERFACE247_tree = null;
        CommonTree IDENT248_tree = null;
        RewriteRuleTokenStream stream_AT = new RewriteRuleTokenStream(adaptor, "token AT");
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_INTERFACE = new RewriteRuleTokenStream(adaptor, "token INTERFACE");
        RewriteRuleSubtreeStream stream_annotationBody = new RewriteRuleSubtreeStream(adaptor, "rule annotationBody");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 68))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:800:5: ( AT INTERFACE IDENT annotationBody -> ^( AT IDENT annotationBody ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:800:9: AT INTERFACE IDENT annotationBody
            {
                AT246 = (Token) match(input, AT, FOLLOW_AT_in_annotationTypeDeclaration8168);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_AT.add(AT246);

                INTERFACE247 = (Token) match(input, INTERFACE, FOLLOW_INTERFACE_in_annotationTypeDeclaration8170);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_INTERFACE.add(INTERFACE247);

                IDENT248 = (Token) match(input, IDENT, FOLLOW_IDENT_in_annotationTypeDeclaration8172);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IDENT.add(IDENT248);

                pushFollow(FOLLOW_annotationBody_in_annotationTypeDeclaration8174);
                annotationBody249 = annotationBody();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_annotationBody.add(annotationBody249.getTree());


                // AST REWRITE
                // elements: IDENT, AT, annotationBody
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 801:9: -> ^( AT IDENT annotationBody )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:801:12: ^( AT IDENT annotationBody )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot(stream_AT.nextNode(), root_1);

                            adaptor.addChild(root_1, modifiers);
                            adaptor.addChild(root_1, stream_IDENT.nextNode());
                            adaptor.addChild(root_1, stream_annotationBody.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 68, annotationTypeDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationTypeDeclaration"

    public static class annotationBody_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationBody"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:804:1: annotationBody : LCURLY ( annotationScopeDeclarations )* RCURLY -> ^( ANNOTATION_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( annotationScopeDeclarations )* ) ;

    public final JavaParser.annotationBody_return annotationBody() throws RecognitionException
    {
        JavaParser.annotationBody_return retval = new JavaParser.annotationBody_return();
        retval.start = input.LT(1);
        int annotationBody_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY250 = null;
        Token RCURLY252 = null;
        JavaParser.annotationScopeDeclarations_return annotationScopeDeclarations251 = null;


        CommonTree LCURLY250_tree = null;
        CommonTree RCURLY252_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_annotationScopeDeclarations = new RewriteRuleSubtreeStream(adaptor, "rule annotationScopeDeclarations");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 69))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:805:5: ( LCURLY ( annotationScopeDeclarations )* RCURLY -> ^( ANNOTATION_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( annotationScopeDeclarations )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:805:9: LCURLY ( annotationScopeDeclarations )* RCURLY
            {
                LCURLY250 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_annotationBody8213);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY250);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:805:16: ( annotationScopeDeclarations )*
                loop84:
                do
                {
                    int alt84 = 2;
                    int LA84_0 = input.LA(1);

                    if ((LA84_0 == AT || LA84_0 == LESS_THAN || LA84_0 == ABSTRACT || LA84_0 == BOOLEAN || LA84_0 == BYTE || (LA84_0 >= CHAR && LA84_0 <= CLASS) || LA84_0 == DOUBLE || LA84_0 == ENUM || LA84_0 == FINAL || LA84_0 == FLOAT || LA84_0 == INTERFACE || (LA84_0 >= INT && LA84_0 <= NATIVE) || (LA84_0 >= PRIVATE && LA84_0 <= PUBLIC) || (LA84_0 >= SHORT && LA84_0 <= STRICTFP) || LA84_0 == SYNCHRONIZED || LA84_0 == TRANSIENT || (LA84_0 >= VOID && LA84_0 <= VOLATILE) || LA84_0 == IDENT))
                    {
                        alt84 = 1;
                    }


                    switch (alt84)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: annotationScopeDeclarations
                        {
                            pushFollow(FOLLOW_annotationScopeDeclarations_in_annotationBody8215);
                            annotationScopeDeclarations251 = annotationScopeDeclarations();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_annotationScopeDeclarations.add(annotationScopeDeclarations251.getTree());

                        }
                        break;

                        default:
                            break loop84;
                    }
                }
                while (true);

                RCURLY252 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_annotationBody8218);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY252);


                // AST REWRITE
                // elements: annotationScopeDeclarations
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 806:9: -> ^( ANNOTATION_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( annotationScopeDeclarations )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:806:13: ^( ANNOTATION_TOP_LEVEL_SCOPE[$LCURLY, \"CLASS_TOP_LEVEL_SCOPE\"] ( annotationScopeDeclarations )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_TOP_LEVEL_SCOPE, LCURLY250, "CLASS_TOP_LEVEL_SCOPE"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:806:76: ( annotationScopeDeclarations )*
                            while (stream_annotationScopeDeclarations.hasNext())
                            {
                                adaptor.addChild(root_1, stream_annotationScopeDeclarations.nextTree());

                            }
                            stream_annotationScopeDeclarations.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 69, annotationBody_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationBody"

    public static class annotationScopeDeclarations_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationScopeDeclarations"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:809:1: annotationScopeDeclarations : ( modifierList type ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI -> ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? ) | classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) ) | typeDeclaration );

    public final JavaParser.annotationScopeDeclarations_return annotationScopeDeclarations() throws RecognitionException
    {
        JavaParser.annotationScopeDeclarations_return retval = new JavaParser.annotationScopeDeclarations_return();
        retval.start = input.LT(1);
        int annotationScopeDeclarations_StartIndex = input.index();
        CommonTree root_0 = null;

        Token IDENT255 = null;
        Token LPAREN256 = null;
        Token RPAREN257 = null;
        Token SEMI259 = null;
        Token SEMI261 = null;
        JavaParser.modifierList_return modifierList253 = null;

        JavaParser.type_return type254 = null;

        JavaParser.annotationDefaultValue_return annotationDefaultValue258 = null;

        JavaParser.classFieldDeclaratorList_return classFieldDeclaratorList260 = null;

        JavaParser.typeDeclaration_return typeDeclaration262 = null;


        CommonTree IDENT255_tree = null;
        CommonTree LPAREN256_tree = null;
        CommonTree RPAREN257_tree = null;
        CommonTree SEMI259_tree = null;
        CommonTree SEMI261_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_SEMI = new RewriteRuleTokenStream(adaptor, "token SEMI");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleSubtreeStream stream_modifierList = new RewriteRuleSubtreeStream(adaptor, "rule modifierList");
        RewriteRuleSubtreeStream stream_annotationDefaultValue = new RewriteRuleSubtreeStream(adaptor, "rule annotationDefaultValue");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        RewriteRuleSubtreeStream stream_classFieldDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule classFieldDeclaratorList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 70))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:810:5: ( modifierList type ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI -> ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? ) | classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) ) | typeDeclaration )
            int alt87 = 2;
            alt87 = dfa87.predict(input);
            switch (alt87)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:810:9: modifierList type ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI -> ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? ) | classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) )
                {
                    pushFollow(FOLLOW_modifierList_in_annotationScopeDeclarations8256);
                    modifierList253 = modifierList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_modifierList.add(modifierList253.getTree());
                    pushFollow(FOLLOW_type_in_annotationScopeDeclarations8258);
                    type254 = type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_type.add(type254.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:811:9: ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI -> ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? ) | classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) )
                    int alt86 = 2;
                    int LA86_0 = input.LA(1);

                    if ((LA86_0 == IDENT))
                    {
                        int LA86_1 = input.LA(2);

                        if ((LA86_1 == LPAREN))
                        {
                            alt86 = 1;
                        }
                        else if ((LA86_1 == ASSIGN || LA86_1 == COMMA || LA86_1 == LBRACK || LA86_1 == SEMI))
                        {
                            alt86 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 86, 1, input);

                            throw nvae;
                        }
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 86, 0, input);

                        throw nvae;
                    }
                    switch (alt86)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:811:13: IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI
                        {
                            IDENT255 = (Token) match(input, IDENT, FOLLOW_IDENT_in_annotationScopeDeclarations8272);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_IDENT.add(IDENT255);

                            LPAREN256 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_annotationScopeDeclarations8274);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_LPAREN.add(LPAREN256);

                            RPAREN257 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_annotationScopeDeclarations8276);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_RPAREN.add(RPAREN257);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:811:33: ( annotationDefaultValue )?
                            int alt85 = 2;
                            int LA85_0 = input.LA(1);

                            if ((LA85_0 == DEFAULT))
                            {
                                alt85 = 1;
                            }
                            switch (alt85)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: annotationDefaultValue
                                {
                                    pushFollow(FOLLOW_annotationDefaultValue_in_annotationScopeDeclarations8278);
                                    annotationDefaultValue258 = annotationDefaultValue();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_annotationDefaultValue.add(annotationDefaultValue258.getTree());

                                }
                                break;

                            }

                            SEMI259 = (Token) match(input, SEMI, FOLLOW_SEMI_in_annotationScopeDeclarations8281);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI259);


                            // AST REWRITE
                            // elements: type, modifierList, annotationDefaultValue, IDENT
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 812:13: -> ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:812:17: ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ANNOTATION_METHOD_DECL, "ANNOTATION_METHOD_DECL"), root_1);

                                        adaptor.addChild(root_1, stream_modifierList.nextTree());
                                        adaptor.addChild(root_1, stream_type.nextTree());
                                        adaptor.addChild(root_1, stream_IDENT.nextNode());
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:812:66: ( annotationDefaultValue )?
                                        if (stream_annotationDefaultValue.hasNext())
                                        {
                                            adaptor.addChild(root_1, stream_annotationDefaultValue.nextTree());

                                        }
                                        stream_annotationDefaultValue.reset();

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:813:13: classFieldDeclaratorList SEMI
                        {
                            pushFollow(FOLLOW_classFieldDeclaratorList_in_annotationScopeDeclarations8323);
                            classFieldDeclaratorList260 = classFieldDeclaratorList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                stream_classFieldDeclaratorList.add(classFieldDeclaratorList260.getTree());
                            SEMI261 = (Token) match(input, SEMI, FOLLOW_SEMI_in_annotationScopeDeclarations8325);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI261);


                            // AST REWRITE
                            // elements: modifierList, type, classFieldDeclaratorList
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 814:13: -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:814:17: ^( VAR_DECLARATION modifierList type classFieldDeclaratorList )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATION, "VAR_DECLARATION"), root_1);

                                        adaptor.addChild(root_1, stream_modifierList.nextTree());
                                        adaptor.addChild(root_1, stream_type.nextTree());
                                        adaptor.addChild(root_1, stream_classFieldDeclaratorList.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:816:9: typeDeclaration
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_typeDeclaration_in_annotationScopeDeclarations8370);
                    typeDeclaration262 = typeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, typeDeclaration262.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 70, annotationScopeDeclarations_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationScopeDeclarations"

    public static class annotationDefaultValue_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "annotationDefaultValue"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:819:1: annotationDefaultValue : DEFAULT annotationElementValue ;

    public final JavaParser.annotationDefaultValue_return annotationDefaultValue() throws RecognitionException
    {
        JavaParser.annotationDefaultValue_return retval = new JavaParser.annotationDefaultValue_return();
        retval.start = input.LT(1);
        int annotationDefaultValue_StartIndex = input.index();
        CommonTree root_0 = null;

        Token DEFAULT263 = null;
        JavaParser.annotationElementValue_return annotationElementValue264 = null;


        CommonTree DEFAULT263_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 71))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:820:5: ( DEFAULT annotationElementValue )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:820:9: DEFAULT annotationElementValue
            {
                root_0 = (CommonTree) adaptor.nil();

                DEFAULT263 = (Token) match(input, DEFAULT, FOLLOW_DEFAULT_in_annotationDefaultValue8389);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    DEFAULT263_tree = (CommonTree) adaptor.create(DEFAULT263);
                    root_0 = (CommonTree) adaptor.becomeRoot(DEFAULT263_tree, root_0);
                }
                pushFollow(FOLLOW_annotationElementValue_in_annotationDefaultValue8392);
                annotationElementValue264 = annotationElementValue();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, annotationElementValue264.getTree());

            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 71, annotationDefaultValue_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "annotationDefaultValue"

    public static class block_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "block"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:825:1: block : LCURLY ( blockStatement )* RCURLY -> ^( BLOCK_SCOPE[$LCURLY, \"BLOCK_SCOPE\"] ( blockStatement )* ) ;

    public final JavaParser.block_return block() throws RecognitionException
    {
        JavaParser.block_return retval = new JavaParser.block_return();
        retval.start = input.LT(1);
        int block_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LCURLY265 = null;
        Token RCURLY267 = null;
        JavaParser.blockStatement_return blockStatement266 = null;


        CommonTree LCURLY265_tree = null;
        CommonTree RCURLY267_tree = null;
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleSubtreeStream stream_blockStatement = new RewriteRuleSubtreeStream(adaptor, "rule blockStatement");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 72))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:826:5: ( LCURLY ( blockStatement )* RCURLY -> ^( BLOCK_SCOPE[$LCURLY, \"BLOCK_SCOPE\"] ( blockStatement )* ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:826:9: LCURLY ( blockStatement )* RCURLY
            {
                LCURLY265 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_block8413);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LCURLY.add(LCURLY265);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:826:16: ( blockStatement )*
                loop88:
                do
                {
                    int alt88 = 2;
                    int LA88_0 = input.LA(1);

                    if ((LA88_0 == AT || LA88_0 == DEC || LA88_0 == INC || LA88_0 == LCURLY || LA88_0 == LESS_THAN || LA88_0 == LOGICAL_NOT || (LA88_0 >= LPAREN && LA88_0 <= MINUS) || LA88_0 == NOT || LA88_0 == PLUS || LA88_0 == SEMI || (LA88_0 >= ABSTRACT && LA88_0 <= BYTE) || (LA88_0 >= CHAR && LA88_0 <= CONTINUE) || (LA88_0 >= DO && LA88_0 <= DOUBLE) || LA88_0 == ENUM || (LA88_0 >= FALSE && LA88_0 <= FINAL) || (LA88_0 >= FLOAT && LA88_0 <= IF) || LA88_0 == INTERFACE || (LA88_0 >= INT && LA88_0 <= NULL) || (LA88_0 >= PRIVATE && LA88_0 <= THROW) || (LA88_0 >= TRANSIENT && LA88_0 <= WHILE) || (LA88_0 >= IDENT && LA88_0 <= STRING_LITERAL)))
                    {
                        alt88 = 1;
                    }


                    switch (alt88)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: blockStatement
                        {
                            pushFollow(FOLLOW_blockStatement_in_block8415);
                            blockStatement266 = blockStatement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_blockStatement.add(blockStatement266.getTree());

                        }
                        break;

                        default:
                            break loop88;
                    }
                }
                while (true);

                RCURLY267 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_block8418);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RCURLY.add(RCURLY267);


                // AST REWRITE
                // elements: blockStatement
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 827:9: -> ^( BLOCK_SCOPE[$LCURLY, \"BLOCK_SCOPE\"] ( blockStatement )* )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:827:13: ^( BLOCK_SCOPE[$LCURLY, \"BLOCK_SCOPE\"] ( blockStatement )* )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(BLOCK_SCOPE, LCURLY265, "BLOCK_SCOPE"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:827:51: ( blockStatement )*
                            while (stream_blockStatement.hasNext())
                            {
                                adaptor.addChild(root_1, stream_blockStatement.nextTree());

                            }
                            stream_blockStatement.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 72, block_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "block"

    public static class blockStatement_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "blockStatement"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:830:1: blockStatement : ( localVariableDeclaration SEMI | typeDeclaration | statement );

    public final JavaParser.blockStatement_return blockStatement() throws RecognitionException
    {
        JavaParser.blockStatement_return retval = new JavaParser.blockStatement_return();
        retval.start = input.LT(1);
        int blockStatement_StartIndex = input.index();
        CommonTree root_0 = null;

        Token SEMI269 = null;
        JavaParser.localVariableDeclaration_return localVariableDeclaration268 = null;

        JavaParser.typeDeclaration_return typeDeclaration270 = null;

        JavaParser.statement_return statement271 = null;


        CommonTree SEMI269_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 73))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:831:5: ( localVariableDeclaration SEMI | typeDeclaration | statement )
            int alt89 = 3;
            alt89 = dfa89.predict(input);
            switch (alt89)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:831:9: localVariableDeclaration SEMI
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_localVariableDeclaration_in_blockStatement8456);
                    localVariableDeclaration268 = localVariableDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, localVariableDeclaration268.getTree());
                    SEMI269 = (Token) match(input, SEMI, FOLLOW_SEMI_in_blockStatement8458);
                    if (state.failed) return retval;

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:832:9: typeDeclaration
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_typeDeclaration_in_blockStatement8469);
                    typeDeclaration270 = typeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, typeDeclaration270.getTree());

                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:833:9: statement
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_statement_in_blockStatement8479);
                    statement271 = statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, statement271.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 73, blockStatement_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "blockStatement"

    public static class localVariableDeclaration_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "localVariableDeclaration"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:836:1: localVariableDeclaration : localModifierList type classFieldDeclaratorList -> ^( VAR_DECLARATION localModifierList type classFieldDeclaratorList ) ;

    public final JavaParser.localVariableDeclaration_return localVariableDeclaration() throws RecognitionException
    {
        JavaParser.localVariableDeclaration_return retval = new JavaParser.localVariableDeclaration_return();
        retval.start = input.LT(1);
        int localVariableDeclaration_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.localModifierList_return localModifierList272 = null;

        JavaParser.type_return type273 = null;

        JavaParser.classFieldDeclaratorList_return classFieldDeclaratorList274 = null;


        RewriteRuleSubtreeStream stream_localModifierList = new RewriteRuleSubtreeStream(adaptor, "rule localModifierList");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        RewriteRuleSubtreeStream stream_classFieldDeclaratorList = new RewriteRuleSubtreeStream(adaptor, "rule classFieldDeclaratorList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 74))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:837:5: ( localModifierList type classFieldDeclaratorList -> ^( VAR_DECLARATION localModifierList type classFieldDeclaratorList ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:837:9: localModifierList type classFieldDeclaratorList
            {
                pushFollow(FOLLOW_localModifierList_in_localVariableDeclaration8498);
                localModifierList272 = localModifierList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_localModifierList.add(localModifierList272.getTree());
                pushFollow(FOLLOW_type_in_localVariableDeclaration8500);
                type273 = type();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_type.add(type273.getTree());
                pushFollow(FOLLOW_classFieldDeclaratorList_in_localVariableDeclaration8502);
                classFieldDeclaratorList274 = classFieldDeclaratorList();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_classFieldDeclaratorList.add(classFieldDeclaratorList274.getTree());


                // AST REWRITE
                // elements: localModifierList, type, classFieldDeclaratorList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 838:9: -> ^( VAR_DECLARATION localModifierList type classFieldDeclaratorList )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:838:13: ^( VAR_DECLARATION localModifierList type classFieldDeclaratorList )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(VAR_DECLARATION, "VAR_DECLARATION"), root_1);

                            adaptor.addChild(root_1, stream_localModifierList.nextTree());
                            adaptor.addChild(root_1, stream_type.nextTree());
                            adaptor.addChild(root_1, stream_classFieldDeclaratorList.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 74, localVariableDeclaration_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "localVariableDeclaration"

    public static class statement_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "statement"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:842:1: statement : ( block | ASSERT expr1= expression ( COLON expr2= expression SEMI -> ^( ASSERT $expr1 $expr2) | SEMI -> ^( ASSERT $expr1) ) | IF parenthesizedExpression ifStat= statement ( ELSE elseStat= statement -> ^( IF parenthesizedExpression $ifStat $elseStat) | -> ^( IF parenthesizedExpression $ifStat) ) | FOR LPAREN ( forInit SEMI forCondition SEMI forUpdater RPAREN statement -> ^( FOR forInit forCondition forUpdater statement ) | localModifierList type IDENT COLON expression RPAREN statement -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement ) ) | WHILE parenthesizedExpression statement -> ^( WHILE parenthesizedExpression statement ) | DO statement WHILE parenthesizedExpression SEMI -> ^( DO statement parenthesizedExpression ) | TRY block ( catches ( finallyClause )? | finallyClause ) -> ^( TRY block ( catches )? ( finallyClause )? ) | SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY -> ^( SWITCH parenthesizedExpression switchBlockLabels ) | SYNCHRONIZED parenthesizedExpression block -> ^( SYNCHRONIZED parenthesizedExpression block ) | RETURN ( expression )? SEMI -> ^( RETURN ( expression )? ) | THROW expression SEMI -> ^( THROW expression ) | BREAK ( IDENT )? SEMI -> ^( BREAK ( IDENT )? ) | CONTINUE ( IDENT )? SEMI -> ^( CONTINUE ( IDENT )? ) | IDENT COLON statement -> ^( LABELED_STATEMENT IDENT statement ) | expression SEMI | SEMI );

    public final JavaParser.statement_return statement() throws RecognitionException
    {
        JavaParser.statement_return retval = new JavaParser.statement_return();
        retval.start = input.LT(1);
        int statement_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ASSERT276 = null;
        Token COLON277 = null;
        Token SEMI278 = null;
        Token SEMI279 = null;
        Token IF280 = null;
        Token ELSE282 = null;
        Token FOR283 = null;
        Token LPAREN284 = null;
        Token SEMI286 = null;
        Token SEMI288 = null;
        Token RPAREN290 = null;
        Token IDENT294 = null;
        Token COLON295 = null;
        Token RPAREN297 = null;
        Token WHILE299 = null;
        Token DO302 = null;
        Token WHILE304 = null;
        Token SEMI306 = null;
        Token TRY307 = null;
        Token SWITCH312 = null;
        Token LCURLY314 = null;
        Token RCURLY316 = null;
        Token SYNCHRONIZED317 = null;
        Token RETURN320 = null;
        Token SEMI322 = null;
        Token THROW323 = null;
        Token SEMI325 = null;
        Token BREAK326 = null;
        Token IDENT327 = null;
        Token SEMI328 = null;
        Token CONTINUE329 = null;
        Token IDENT330 = null;
        Token SEMI331 = null;
        Token IDENT332 = null;
        Token COLON333 = null;
        Token SEMI336 = null;
        Token SEMI337 = null;
        JavaParser.expression_return expr1 = null;

        JavaParser.expression_return expr2 = null;

        JavaParser.statement_return ifStat = null;

        JavaParser.statement_return elseStat = null;

        JavaParser.block_return block275 = null;

        JavaParser.parenthesizedExpression_return parenthesizedExpression281 = null;

        JavaParser.forInit_return forInit285 = null;

        JavaParser.forCondition_return forCondition287 = null;

        JavaParser.forUpdater_return forUpdater289 = null;

        JavaParser.statement_return statement291 = null;

        JavaParser.localModifierList_return localModifierList292 = null;

        JavaParser.type_return type293 = null;

        JavaParser.expression_return expression296 = null;

        JavaParser.statement_return statement298 = null;

        JavaParser.parenthesizedExpression_return parenthesizedExpression300 = null;

        JavaParser.statement_return statement301 = null;

        JavaParser.statement_return statement303 = null;

        JavaParser.parenthesizedExpression_return parenthesizedExpression305 = null;

        JavaParser.block_return block308 = null;

        JavaParser.catches_return catches309 = null;

        JavaParser.finallyClause_return finallyClause310 = null;

        JavaParser.finallyClause_return finallyClause311 = null;

        JavaParser.parenthesizedExpression_return parenthesizedExpression313 = null;

        JavaParser.switchBlockLabels_return switchBlockLabels315 = null;

        JavaParser.parenthesizedExpression_return parenthesizedExpression318 = null;

        JavaParser.block_return block319 = null;

        JavaParser.expression_return expression321 = null;

        JavaParser.expression_return expression324 = null;

        JavaParser.statement_return statement334 = null;

        JavaParser.expression_return expression335 = null;


        CommonTree ASSERT276_tree = null;
        CommonTree COLON277_tree = null;
        CommonTree SEMI278_tree = null;
        CommonTree SEMI279_tree = null;
        CommonTree IF280_tree = null;
        CommonTree ELSE282_tree = null;
        CommonTree FOR283_tree = null;
        CommonTree LPAREN284_tree = null;
        CommonTree SEMI286_tree = null;
        CommonTree SEMI288_tree = null;
        CommonTree RPAREN290_tree = null;
        CommonTree IDENT294_tree = null;
        CommonTree COLON295_tree = null;
        CommonTree RPAREN297_tree = null;
        CommonTree WHILE299_tree = null;
        CommonTree DO302_tree = null;
        CommonTree WHILE304_tree = null;
        CommonTree SEMI306_tree = null;
        CommonTree TRY307_tree = null;
        CommonTree SWITCH312_tree = null;
        CommonTree LCURLY314_tree = null;
        CommonTree RCURLY316_tree = null;
        CommonTree SYNCHRONIZED317_tree = null;
        CommonTree RETURN320_tree = null;
        CommonTree SEMI322_tree = null;
        CommonTree THROW323_tree = null;
        CommonTree SEMI325_tree = null;
        CommonTree BREAK326_tree = null;
        CommonTree IDENT327_tree = null;
        CommonTree SEMI328_tree = null;
        CommonTree CONTINUE329_tree = null;
        CommonTree IDENT330_tree = null;
        CommonTree SEMI331_tree = null;
        CommonTree IDENT332_tree = null;
        CommonTree COLON333_tree = null;
        CommonTree SEMI336_tree = null;
        CommonTree SEMI337_tree = null;
        RewriteRuleTokenStream stream_COLON = new RewriteRuleTokenStream(adaptor, "token COLON");
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_SYNCHRONIZED = new RewriteRuleTokenStream(adaptor, "token SYNCHRONIZED");
        RewriteRuleTokenStream stream_WHILE = new RewriteRuleTokenStream(adaptor, "token WHILE");
        RewriteRuleTokenStream stream_CONTINUE = new RewriteRuleTokenStream(adaptor, "token CONTINUE");
        RewriteRuleTokenStream stream_SWITCH = new RewriteRuleTokenStream(adaptor, "token SWITCH");
        RewriteRuleTokenStream stream_RCURLY = new RewriteRuleTokenStream(adaptor, "token RCURLY");
        RewriteRuleTokenStream stream_ELSE = new RewriteRuleTokenStream(adaptor, "token ELSE");
        RewriteRuleTokenStream stream_RETURN = new RewriteRuleTokenStream(adaptor, "token RETURN");
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_FOR = new RewriteRuleTokenStream(adaptor, "token FOR");
        RewriteRuleTokenStream stream_DO = new RewriteRuleTokenStream(adaptor, "token DO");
        RewriteRuleTokenStream stream_LCURLY = new RewriteRuleTokenStream(adaptor, "token LCURLY");
        RewriteRuleTokenStream stream_SEMI = new RewriteRuleTokenStream(adaptor, "token SEMI");
        RewriteRuleTokenStream stream_ASSERT = new RewriteRuleTokenStream(adaptor, "token ASSERT");
        RewriteRuleTokenStream stream_BREAK = new RewriteRuleTokenStream(adaptor, "token BREAK");
        RewriteRuleTokenStream stream_THROW = new RewriteRuleTokenStream(adaptor, "token THROW");
        RewriteRuleTokenStream stream_TRY = new RewriteRuleTokenStream(adaptor, "token TRY");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleTokenStream stream_IF = new RewriteRuleTokenStream(adaptor, "token IF");
        RewriteRuleSubtreeStream stream_statement = new RewriteRuleSubtreeStream(adaptor, "rule statement");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor, "rule expression");
        RewriteRuleSubtreeStream stream_finallyClause = new RewriteRuleSubtreeStream(adaptor, "rule finallyClause");
        RewriteRuleSubtreeStream stream_catches = new RewriteRuleSubtreeStream(adaptor, "rule catches");
        RewriteRuleSubtreeStream stream_forUpdater = new RewriteRuleSubtreeStream(adaptor, "rule forUpdater");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor, "rule block");
        RewriteRuleSubtreeStream stream_forCondition = new RewriteRuleSubtreeStream(adaptor, "rule forCondition");
        RewriteRuleSubtreeStream stream_localModifierList = new RewriteRuleSubtreeStream(adaptor, "rule localModifierList");
        RewriteRuleSubtreeStream stream_forInit = new RewriteRuleSubtreeStream(adaptor, "rule forInit");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor, "rule type");
        RewriteRuleSubtreeStream stream_switchBlockLabels = new RewriteRuleSubtreeStream(adaptor, "rule switchBlockLabels");
        RewriteRuleSubtreeStream stream_parenthesizedExpression = new RewriteRuleSubtreeStream(adaptor, "rule parenthesizedExpression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 75))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:843:5: ( block | ASSERT expr1= expression ( COLON expr2= expression SEMI -> ^( ASSERT $expr1 $expr2) | SEMI -> ^( ASSERT $expr1) ) | IF parenthesizedExpression ifStat= statement ( ELSE elseStat= statement -> ^( IF parenthesizedExpression $ifStat $elseStat) | -> ^( IF parenthesizedExpression $ifStat) ) | FOR LPAREN ( forInit SEMI forCondition SEMI forUpdater RPAREN statement -> ^( FOR forInit forCondition forUpdater statement ) | localModifierList type IDENT COLON expression RPAREN statement -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement ) ) | WHILE parenthesizedExpression statement -> ^( WHILE parenthesizedExpression statement ) | DO statement WHILE parenthesizedExpression SEMI -> ^( DO statement parenthesizedExpression ) | TRY block ( catches ( finallyClause )? | finallyClause ) -> ^( TRY block ( catches )? ( finallyClause )? ) | SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY -> ^( SWITCH parenthesizedExpression switchBlockLabels ) | SYNCHRONIZED parenthesizedExpression block -> ^( SYNCHRONIZED parenthesizedExpression block ) | RETURN ( expression )? SEMI -> ^( RETURN ( expression )? ) | THROW expression SEMI -> ^( THROW expression ) | BREAK ( IDENT )? SEMI -> ^( BREAK ( IDENT )? ) | CONTINUE ( IDENT )? SEMI -> ^( CONTINUE ( IDENT )? ) | IDENT COLON statement -> ^( LABELED_STATEMENT IDENT statement ) | expression SEMI | SEMI )
            int alt98 = 16;
            alt98 = dfa98.predict(input);
            switch (alt98)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:843:9: block
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_block_in_statement8543);
                    block275 = block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, block275.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:844:9: ASSERT expr1= expression ( COLON expr2= expression SEMI -> ^( ASSERT $expr1 $expr2) | SEMI -> ^( ASSERT $expr1) )
                {
                    ASSERT276 = (Token) match(input, ASSERT, FOLLOW_ASSERT_in_statement8553);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_ASSERT.add(ASSERT276);

                    pushFollow(FOLLOW_expression_in_statement8557);
                    expr1 = expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_expression.add(expr1.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:845:9: ( COLON expr2= expression SEMI -> ^( ASSERT $expr1 $expr2) | SEMI -> ^( ASSERT $expr1) )
                    int alt90 = 2;
                    int LA90_0 = input.LA(1);

                    if ((LA90_0 == COLON))
                    {
                        alt90 = 1;
                    }
                    else if ((LA90_0 == SEMI))
                    {
                        alt90 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 90, 0, input);

                        throw nvae;
                    }
                    switch (alt90)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:845:13: COLON expr2= expression SEMI
                        {
                            COLON277 = (Token) match(input, COLON, FOLLOW_COLON_in_statement8571);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COLON.add(COLON277);

                            pushFollow(FOLLOW_expression_in_statement8575);
                            expr2 = expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_expression.add(expr2.getTree());
                            SEMI278 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement8577);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI278);


                            // AST REWRITE
                            // elements: ASSERT, expr2, expr1
                            // token labels: 
                            // rule labels: retval, expr1, expr2
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                                RewriteRuleSubtreeStream stream_expr1 = new RewriteRuleSubtreeStream(adaptor, "rule expr1", expr1 != null ? expr1.tree : null);
                                RewriteRuleSubtreeStream stream_expr2 = new RewriteRuleSubtreeStream(adaptor, "rule expr2", expr2 != null ? expr2.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 845:77: -> ^( ASSERT $expr1 $expr2)
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:845:81: ^( ASSERT $expr1 $expr2)
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_ASSERT.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_expr1.nextTree());
                                        adaptor.addChild(root_1, stream_expr2.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:846:13: SEMI
                        {
                            SEMI279 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement8640);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI279);


                            // AST REWRITE
                            // elements: ASSERT, expr1
                            // token labels: 
                            // rule labels: retval, expr1
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                                RewriteRuleSubtreeStream stream_expr1 = new RewriteRuleSubtreeStream(adaptor, "rule expr1", expr1 != null ? expr1.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 846:77: -> ^( ASSERT $expr1)
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:846:81: ^( ASSERT $expr1)
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_ASSERT.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_expr1.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:848:9: IF parenthesizedExpression ifStat= statement ( ELSE elseStat= statement -> ^( IF parenthesizedExpression $ifStat $elseStat) | -> ^( IF parenthesizedExpression $ifStat) )
                {
                    IF280 = (Token) match(input, IF, FOLLOW_IF_in_statement8729);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_IF.add(IF280);

                    pushFollow(FOLLOW_parenthesizedExpression_in_statement8731);
                    parenthesizedExpression281 = parenthesizedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_parenthesizedExpression.add(parenthesizedExpression281.getTree());
                    pushFollow(FOLLOW_statement_in_statement8735);
                    ifStat = statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_statement.add(ifStat.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:849:9: ( ELSE elseStat= statement -> ^( IF parenthesizedExpression $ifStat $elseStat) | -> ^( IF parenthesizedExpression $ifStat) )
                    int alt91 = 2;
                    int LA91_0 = input.LA(1);

                    if ((LA91_0 == ELSE))
                    {
                        int LA91_1 = input.LA(2);

                        if ((synpred122_Java()))
                        {
                            alt91 = 1;
                        }
                        else if ((true))
                        {
                            alt91 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 91, 1, input);

                            throw nvae;
                        }
                    }
                    else if ((LA91_0 == EOF || LA91_0 == AT || LA91_0 == DEC || LA91_0 == INC || LA91_0 == LCURLY || LA91_0 == LESS_THAN || LA91_0 == LOGICAL_NOT || (LA91_0 >= LPAREN && LA91_0 <= MINUS) || LA91_0 == NOT || LA91_0 == PLUS || LA91_0 == RCURLY || LA91_0 == SEMI || (LA91_0 >= ABSTRACT && LA91_0 <= CASE) || (LA91_0 >= CHAR && LA91_0 <= DOUBLE) || LA91_0 == ENUM || (LA91_0 >= FALSE && LA91_0 <= FINAL) || (LA91_0 >= FLOAT && LA91_0 <= IF) || LA91_0 == INTERFACE || (LA91_0 >= INT && LA91_0 <= NULL) || (LA91_0 >= PRIVATE && LA91_0 <= THROW) || (LA91_0 >= TRANSIENT && LA91_0 <= WHILE) || (LA91_0 >= IDENT && LA91_0 <= STRING_LITERAL)))
                    {
                        alt91 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 91, 0, input);

                        throw nvae;
                    }
                    switch (alt91)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:849:13: ELSE elseStat= statement
                        {
                            ELSE282 = (Token) match(input, ELSE, FOLLOW_ELSE_in_statement8749);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_ELSE.add(ELSE282);

                            pushFollow(FOLLOW_statement_in_statement8753);
                            elseStat = statement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_statement.add(elseStat.getTree());


                            // AST REWRITE
                            // elements: ifStat, IF, parenthesizedExpression, elseStat
                            // token labels: 
                            // rule labels: retval, ifStat, elseStat
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                                RewriteRuleSubtreeStream stream_ifStat = new RewriteRuleSubtreeStream(adaptor, "rule ifStat", ifStat != null ? ifStat.tree : null);
                                RewriteRuleSubtreeStream stream_elseStat = new RewriteRuleSubtreeStream(adaptor, "rule elseStat", elseStat != null ? elseStat.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 849:77: -> ^( IF parenthesizedExpression $ifStat $elseStat)
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:849:81: ^( IF parenthesizedExpression $ifStat $elseStat)
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_IF.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_parenthesizedExpression.nextTree());
                                        adaptor.addChild(root_1, stream_ifStat.nextTree());
                                        adaptor.addChild(root_1, stream_elseStat.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:850:77: 
                        {

                            // AST REWRITE
                            // elements: parenthesizedExpression, IF, ifStat
                            // token labels: 
                            // rule labels: retval, ifStat
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                                RewriteRuleSubtreeStream stream_ifStat = new RewriteRuleSubtreeStream(adaptor, "rule ifStat", ifStat != null ? ifStat.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 850:77: -> ^( IF parenthesizedExpression $ifStat)
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:850:81: ^( IF parenthesizedExpression $ifStat)
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_IF.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_parenthesizedExpression.nextTree());
                                        adaptor.addChild(root_1, stream_ifStat.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:852:9: FOR LPAREN ( forInit SEMI forCondition SEMI forUpdater RPAREN statement -> ^( FOR forInit forCondition forUpdater statement ) | localModifierList type IDENT COLON expression RPAREN statement -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement ) )
                {
                    FOR283 = (Token) match(input, FOR, FOLLOW_FOR_in_statement8916);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_FOR.add(FOR283);

                    LPAREN284 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_statement8918);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_LPAREN.add(LPAREN284);

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:853:9: ( forInit SEMI forCondition SEMI forUpdater RPAREN statement -> ^( FOR forInit forCondition forUpdater statement ) | localModifierList type IDENT COLON expression RPAREN statement -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement ) )
                    int alt92 = 2;
                    alt92 = dfa92.predict(input);
                    switch (alt92)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:853:13: forInit SEMI forCondition SEMI forUpdater RPAREN statement
                        {
                            pushFollow(FOLLOW_forInit_in_statement8932);
                            forInit285 = forInit();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_forInit.add(forInit285.getTree());
                            SEMI286 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement8934);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI286);

                            pushFollow(FOLLOW_forCondition_in_statement8936);
                            forCondition287 = forCondition();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_forCondition.add(forCondition287.getTree());
                            SEMI288 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement8938);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SEMI.add(SEMI288);

                            pushFollow(FOLLOW_forUpdater_in_statement8940);
                            forUpdater289 = forUpdater();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_forUpdater.add(forUpdater289.getTree());
                            RPAREN290 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_statement8942);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_RPAREN.add(RPAREN290);

                            pushFollow(FOLLOW_statement_in_statement8944);
                            statement291 = statement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_statement.add(statement291.getTree());


                            // AST REWRITE
                            // elements: FOR, forUpdater, forCondition, statement, forInit
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 853:77: -> ^( FOR forInit forCondition forUpdater statement )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:853:81: ^( FOR forInit forCondition forUpdater statement )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_FOR.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_forInit.nextTree());
                                        adaptor.addChild(root_1, stream_forCondition.nextTree());
                                        adaptor.addChild(root_1, stream_forUpdater.nextTree());
                                        adaptor.addChild(root_1, stream_statement.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:854:13: localModifierList type IDENT COLON expression RPAREN statement
                        {
                            pushFollow(FOLLOW_localModifierList_in_statement8978);
                            localModifierList292 = localModifierList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_localModifierList.add(localModifierList292.getTree());
                            pushFollow(FOLLOW_type_in_statement8980);
                            type293 = type();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_type.add(type293.getTree());
                            IDENT294 = (Token) match(input, IDENT, FOLLOW_IDENT_in_statement8982);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_IDENT.add(IDENT294);

                            COLON295 = (Token) match(input, COLON, FOLLOW_COLON_in_statement8984);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_COLON.add(COLON295);

                            pushFollow(FOLLOW_expression_in_statement8986);
                            expression296 = expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_expression.add(expression296.getTree());
                            RPAREN297 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_statement8988);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_RPAREN.add(RPAREN297);

                            pushFollow(FOLLOW_statement_in_statement8990);
                            statement298 = statement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_statement.add(statement298.getTree());


                            // AST REWRITE
                            // elements: type, statement, expression, localModifierList, IDENT
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 855:77: -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:855:81: ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FOR_EACH, FOR283, "FOR_EACH"), root_1);

                                        adaptor.addChild(root_1, stream_localModifierList.nextTree());
                                        adaptor.addChild(root_1, stream_type.nextTree());
                                        adaptor.addChild(root_1, stream_IDENT.nextNode());
                                        adaptor.addChild(root_1, stream_expression.nextTree());
                                        adaptor.addChild(root_1, stream_statement.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:857:9: WHILE parenthesizedExpression statement
                {
                    WHILE299 = (Token) match(input, WHILE, FOLLOW_WHILE_in_statement9104);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_WHILE.add(WHILE299);

                    pushFollow(FOLLOW_parenthesizedExpression_in_statement9106);
                    parenthesizedExpression300 = parenthesizedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_parenthesizedExpression.add(parenthesizedExpression300.getTree());
                    pushFollow(FOLLOW_statement_in_statement9108);
                    statement301 = statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_statement.add(statement301.getTree());


                    // AST REWRITE
                    // elements: WHILE, statement, parenthesizedExpression
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 857:77: -> ^( WHILE parenthesizedExpression statement )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:857:81: ^( WHILE parenthesizedExpression statement )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_WHILE.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_parenthesizedExpression.nextTree());
                                adaptor.addChild(root_1, stream_statement.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 6:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:858:9: DO statement WHILE parenthesizedExpression SEMI
                {
                    DO302 = (Token) match(input, DO, FOLLOW_DO_in_statement9157);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_DO.add(DO302);

                    pushFollow(FOLLOW_statement_in_statement9159);
                    statement303 = statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_statement.add(statement303.getTree());
                    WHILE304 = (Token) match(input, WHILE, FOLLOW_WHILE_in_statement9161);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_WHILE.add(WHILE304);

                    pushFollow(FOLLOW_parenthesizedExpression_in_statement9163);
                    parenthesizedExpression305 = parenthesizedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_parenthesizedExpression.add(parenthesizedExpression305.getTree());
                    SEMI306 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9165);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SEMI.add(SEMI306);


                    // AST REWRITE
                    // elements: statement, parenthesizedExpression, DO
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 858:77: -> ^( DO statement parenthesizedExpression )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:858:81: ^( DO statement parenthesizedExpression )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_DO.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_statement.nextTree());
                                adaptor.addChild(root_1, stream_parenthesizedExpression.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 7:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:9: TRY block ( catches ( finallyClause )? | finallyClause )
                {
                    TRY307 = (Token) match(input, TRY, FOLLOW_TRY_in_statement9206);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_TRY.add(TRY307);

                    pushFollow(FOLLOW_block_in_statement9208);
                    block308 = block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_block.add(block308.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:19: ( catches ( finallyClause )? | finallyClause )
                    int alt94 = 2;
                    int LA94_0 = input.LA(1);

                    if ((LA94_0 == CATCH))
                    {
                        alt94 = 1;
                    }
                    else if ((LA94_0 == FINALLY))
                    {
                        alt94 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 94, 0, input);

                        throw nvae;
                    }
                    switch (alt94)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:20: catches ( finallyClause )?
                        {
                            pushFollow(FOLLOW_catches_in_statement9211);
                            catches309 = catches();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_catches.add(catches309.getTree());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:28: ( finallyClause )?
                            int alt93 = 2;
                            int LA93_0 = input.LA(1);

                            if ((LA93_0 == FINALLY))
                            {
                                alt93 = 1;
                            }
                            switch (alt93)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: finallyClause
                                {
                                    pushFollow(FOLLOW_finallyClause_in_statement9213);
                                    finallyClause310 = finallyClause();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_finallyClause.add(finallyClause310.getTree());

                                }
                                break;

                            }


                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:45: finallyClause
                        {
                            pushFollow(FOLLOW_finallyClause_in_statement9218);
                            finallyClause311 = finallyClause();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_finallyClause.add(finallyClause311.getTree());

                        }
                        break;

                    }


                    // AST REWRITE
                    // elements: finallyClause, catches, TRY, block
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 859:77: -> ^( TRY block ( catches )? ( finallyClause )? )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:81: ^( TRY block ( catches )? ( finallyClause )? )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_TRY.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_block.nextTree());
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:93: ( catches )?
                                if (stream_catches.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_catches.nextTree());

                                }
                                stream_catches.reset();
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:859:102: ( finallyClause )?
                                if (stream_finallyClause.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_finallyClause.nextTree());

                                }
                                stream_finallyClause.reset();

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 8:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:860:9: SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY
                {
                    SWITCH312 = (Token) match(input, SWITCH, FOLLOW_SWITCH_in_statement9261);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SWITCH.add(SWITCH312);

                    pushFollow(FOLLOW_parenthesizedExpression_in_statement9263);
                    parenthesizedExpression313 = parenthesizedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_parenthesizedExpression.add(parenthesizedExpression313.getTree());
                    LCURLY314 = (Token) match(input, LCURLY, FOLLOW_LCURLY_in_statement9265);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_LCURLY.add(LCURLY314);

                    pushFollow(FOLLOW_switchBlockLabels_in_statement9267);
                    switchBlockLabels315 = switchBlockLabels();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_switchBlockLabels.add(switchBlockLabels315.getTree());
                    RCURLY316 = (Token) match(input, RCURLY, FOLLOW_RCURLY_in_statement9269);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_RCURLY.add(RCURLY316);


                    // AST REWRITE
                    // elements: switchBlockLabels, parenthesizedExpression, SWITCH
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 860:77: -> ^( SWITCH parenthesizedExpression switchBlockLabels )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:860:81: ^( SWITCH parenthesizedExpression switchBlockLabels )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_SWITCH.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_parenthesizedExpression.nextTree());
                                adaptor.addChild(root_1, stream_switchBlockLabels.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 9:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:861:9: SYNCHRONIZED parenthesizedExpression block
                {
                    SYNCHRONIZED317 = (Token) match(input, SYNCHRONIZED, FOLLOW_SYNCHRONIZED_in_statement9295);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SYNCHRONIZED.add(SYNCHRONIZED317);

                    pushFollow(FOLLOW_parenthesizedExpression_in_statement9297);
                    parenthesizedExpression318 = parenthesizedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_parenthesizedExpression.add(parenthesizedExpression318.getTree());
                    pushFollow(FOLLOW_block_in_statement9299);
                    block319 = block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_block.add(block319.getTree());


                    // AST REWRITE
                    // elements: SYNCHRONIZED, parenthesizedExpression, block
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 861:77: -> ^( SYNCHRONIZED parenthesizedExpression block )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:861:81: ^( SYNCHRONIZED parenthesizedExpression block )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_SYNCHRONIZED.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_parenthesizedExpression.nextTree());
                                adaptor.addChild(root_1, stream_block.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 10:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:862:9: RETURN ( expression )? SEMI
                {
                    RETURN320 = (Token) match(input, RETURN, FOLLOW_RETURN_in_statement9345);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_RETURN.add(RETURN320);

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:862:16: ( expression )?
                    int alt95 = 2;
                    int LA95_0 = input.LA(1);

                    if ((LA95_0 == DEC || LA95_0 == INC || LA95_0 == LESS_THAN || LA95_0 == LOGICAL_NOT || (LA95_0 >= LPAREN && LA95_0 <= MINUS) || LA95_0 == NOT || LA95_0 == PLUS || LA95_0 == BOOLEAN || LA95_0 == BYTE || LA95_0 == CHAR || LA95_0 == DOUBLE || LA95_0 == FALSE || LA95_0 == FLOAT || (LA95_0 >= INT && LA95_0 <= LONG) || (LA95_0 >= NEW && LA95_0 <= NULL) || LA95_0 == SHORT || LA95_0 == SUPER || LA95_0 == THIS || LA95_0 == TRUE || LA95_0 == VOID || (LA95_0 >= IDENT && LA95_0 <= STRING_LITERAL)))
                    {
                        alt95 = 1;
                    }
                    switch (alt95)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: expression
                        {
                            pushFollow(FOLLOW_expression_in_statement9347);
                            expression321 = expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_expression.add(expression321.getTree());

                        }
                        break;

                    }

                    SEMI322 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9350);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SEMI.add(SEMI322);


                    // AST REWRITE
                    // elements: expression, RETURN
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 862:77: -> ^( RETURN ( expression )? )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:862:81: ^( RETURN ( expression )? )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_RETURN.nextNode(), root_1);

                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:862:90: ( expression )?
                                if (stream_expression.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_expression.nextTree());

                                }
                                stream_expression.reset();

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 11:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:863:9: THROW expression SEMI
                {
                    THROW323 = (Token) match(input, THROW, FOLLOW_THROW_in_statement9414);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_THROW.add(THROW323);

                    pushFollow(FOLLOW_expression_in_statement9416);
                    expression324 = expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_expression.add(expression324.getTree());
                    SEMI325 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9418);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SEMI.add(SEMI325);


                    // AST REWRITE
                    // elements: expression, THROW
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 863:77: -> ^( THROW expression )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:863:81: ^( THROW expression )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_THROW.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_expression.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 12:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:864:9: BREAK ( IDENT )? SEMI
                {
                    BREAK326 = (Token) match(input, BREAK, FOLLOW_BREAK_in_statement9483);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_BREAK.add(BREAK326);

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:864:15: ( IDENT )?
                    int alt96 = 2;
                    int LA96_0 = input.LA(1);

                    if ((LA96_0 == IDENT))
                    {
                        alt96 = 1;
                    }
                    switch (alt96)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: IDENT
                        {
                            IDENT327 = (Token) match(input, IDENT, FOLLOW_IDENT_in_statement9485);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_IDENT.add(IDENT327);


                        }
                        break;

                    }

                    SEMI328 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9488);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SEMI.add(SEMI328);


                    // AST REWRITE
                    // elements: BREAK, IDENT
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 864:77: -> ^( BREAK ( IDENT )? )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:864:81: ^( BREAK ( IDENT )? )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_BREAK.nextNode(), root_1);

                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:864:89: ( IDENT )?
                                if (stream_IDENT.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_IDENT.nextNode());

                                }
                                stream_IDENT.reset();

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 13:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:865:9: CONTINUE ( IDENT )? SEMI
                {
                    CONTINUE329 = (Token) match(input, CONTINUE, FOLLOW_CONTINUE_in_statement9558);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_CONTINUE.add(CONTINUE329);

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:865:18: ( IDENT )?
                    int alt97 = 2;
                    int LA97_0 = input.LA(1);

                    if ((LA97_0 == IDENT))
                    {
                        alt97 = 1;
                    }
                    switch (alt97)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: IDENT
                        {
                            IDENT330 = (Token) match(input, IDENT, FOLLOW_IDENT_in_statement9560);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_IDENT.add(IDENT330);


                        }
                        break;

                    }

                    SEMI331 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9563);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SEMI.add(SEMI331);


                    // AST REWRITE
                    // elements: IDENT, CONTINUE
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 865:77: -> ^( CONTINUE ( IDENT )? )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:865:81: ^( CONTINUE ( IDENT )? )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_CONTINUE.nextNode(), root_1);

                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:865:92: ( IDENT )?
                                if (stream_IDENT.hasNext())
                                {
                                    adaptor.addChild(root_1, stream_IDENT.nextNode());

                                }
                                stream_IDENT.reset();

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 14:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:866:9: IDENT COLON statement
                {
                    IDENT332 = (Token) match(input, IDENT, FOLLOW_IDENT_in_statement9630);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_IDENT.add(IDENT332);

                    COLON333 = (Token) match(input, COLON, FOLLOW_COLON_in_statement9632);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_COLON.add(COLON333);

                    pushFollow(FOLLOW_statement_in_statement9634);
                    statement334 = statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_statement.add(statement334.getTree());


                    // AST REWRITE
                    // elements: IDENT, statement
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 866:77: -> ^( LABELED_STATEMENT IDENT statement )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:866:81: ^( LABELED_STATEMENT IDENT statement )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(LABELED_STATEMENT, "LABELED_STATEMENT"), root_1);

                                adaptor.addChild(root_1, stream_IDENT.nextNode());
                                adaptor.addChild(root_1, stream_statement.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 15:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:867:9: expression SEMI
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_expression_in_statement9701);
                    expression335 = expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, expression335.getTree());
                    SEMI336 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9703);
                    if (state.failed) return retval;

                }
                break;
                case 16:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:868:9: SEMI
                {
                    root_0 = (CommonTree) adaptor.nil();

                    SEMI337 = (Token) match(input, SEMI, FOLLOW_SEMI_in_statement9714);
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                    {
                        SEMI337_tree = (CommonTree) adaptor.create(SEMI337);
                        adaptor.addChild(root_0, SEMI337_tree);
                    }

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 75, statement_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class catches_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "catches"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:871:1: catches : ( catchClause )+ -> ^( CATCH_CLAUSE_LIST ( catchClause )+ ) ;

    public final JavaParser.catches_return catches() throws RecognitionException
    {
        JavaParser.catches_return retval = new JavaParser.catches_return();
        retval.start = input.LT(1);
        int catches_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.catchClause_return catchClause338 = null;


        RewriteRuleSubtreeStream stream_catchClause = new RewriteRuleSubtreeStream(adaptor, "rule catchClause");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 76))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:872:5: ( ( catchClause )+ -> ^( CATCH_CLAUSE_LIST ( catchClause )+ ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:872:9: ( catchClause )+
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:872:9: ( catchClause )+
                int cnt99 = 0;
                loop99:
                do
                {
                    int alt99 = 2;
                    int LA99_0 = input.LA(1);

                    if ((LA99_0 == CATCH))
                    {
                        alt99 = 1;
                    }


                    switch (alt99)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: catchClause
                        {
                            pushFollow(FOLLOW_catchClause_in_catches9734);
                            catchClause338 = catchClause();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_catchClause.add(catchClause338.getTree());

                        }
                        break;

                        default:
                            if (cnt99 >= 1) break loop99;
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            EarlyExitException eee =
                                    new EarlyExitException(99, input);
                            throw eee;
                    }
                    cnt99++;
                }
                while (true);


                // AST REWRITE
                // elements: catchClause
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 873:9: -> ^( CATCH_CLAUSE_LIST ( catchClause )+ )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:873:13: ^( CATCH_CLAUSE_LIST ( catchClause )+ )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CATCH_CLAUSE_LIST, "CATCH_CLAUSE_LIST"), root_1);

                            if (!(stream_catchClause.hasNext()))
                            {
                                throw new RewriteEarlyExitException();
                            }
                            while (stream_catchClause.hasNext())
                            {
                                adaptor.addChild(root_1, stream_catchClause.nextTree());

                            }
                            stream_catchClause.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 76, catches_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "catches"

    public static class catchClause_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "catchClause"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:876:1: catchClause : CATCH LPAREN formalParameterStandardDecl RPAREN block ;

    public final JavaParser.catchClause_return catchClause() throws RecognitionException
    {
        JavaParser.catchClause_return retval = new JavaParser.catchClause_return();
        retval.start = input.LT(1);
        int catchClause_StartIndex = input.index();
        CommonTree root_0 = null;

        Token CATCH339 = null;
        Token LPAREN340 = null;
        Token RPAREN342 = null;
        JavaParser.formalParameterStandardDecl_return formalParameterStandardDecl341 = null;

        JavaParser.block_return block343 = null;


        CommonTree CATCH339_tree = null;
        CommonTree LPAREN340_tree = null;
        CommonTree RPAREN342_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 77))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:877:5: ( CATCH LPAREN formalParameterStandardDecl RPAREN block )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:877:9: CATCH LPAREN formalParameterStandardDecl RPAREN block
            {
                root_0 = (CommonTree) adaptor.nil();

                CATCH339 = (Token) match(input, CATCH, FOLLOW_CATCH_in_catchClause9772);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    CATCH339_tree = (CommonTree) adaptor.create(CATCH339);
                    root_0 = (CommonTree) adaptor.becomeRoot(CATCH339_tree, root_0);
                }
                LPAREN340 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_catchClause9775);
                if (state.failed) return retval;
                pushFollow(FOLLOW_formalParameterStandardDecl_in_catchClause9778);
                formalParameterStandardDecl341 = formalParameterStandardDecl();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, formalParameterStandardDecl341.getTree());
                RPAREN342 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_catchClause9780);
                if (state.failed) return retval;
                pushFollow(FOLLOW_block_in_catchClause9783);
                block343 = block();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, block343.getTree());

            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 77, catchClause_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "catchClause"

    public static class finallyClause_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "finallyClause"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:880:1: finallyClause : FINALLY block -> block ;

    public final JavaParser.finallyClause_return finallyClause() throws RecognitionException
    {
        JavaParser.finallyClause_return retval = new JavaParser.finallyClause_return();
        retval.start = input.LT(1);
        int finallyClause_StartIndex = input.index();
        CommonTree root_0 = null;

        Token FINALLY344 = null;
        JavaParser.block_return block345 = null;


        CommonTree FINALLY344_tree = null;
        RewriteRuleTokenStream stream_FINALLY = new RewriteRuleTokenStream(adaptor, "token FINALLY");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor, "rule block");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 78))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:881:5: ( FINALLY block -> block )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:881:9: FINALLY block
            {
                FINALLY344 = (Token) match(input, FINALLY, FOLLOW_FINALLY_in_finallyClause9802);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_FINALLY.add(FINALLY344);

                pushFollow(FOLLOW_block_in_finallyClause9804);
                block345 = block();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_block.add(block345.getTree());


                // AST REWRITE
                // elements: block
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 882:9: -> block
                    {
                        adaptor.addChild(root_0, stream_block.nextTree());

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 78, finallyClause_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "finallyClause"

    public static class switchBlockLabels_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "switchBlockLabels"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:885:1: switchBlockLabels : preCases= switchCaseLabels ( switchDefaultLabel )? postCases= switchCaseLabels -> ^( SWITCH_BLOCK_LABEL_LIST ( $preCases)? ( switchDefaultLabel )? ( $postCases)? ) ;

    public final JavaParser.switchBlockLabels_return switchBlockLabels() throws RecognitionException
    {
        JavaParser.switchBlockLabels_return retval = new JavaParser.switchBlockLabels_return();
        retval.start = input.LT(1);
        int switchBlockLabels_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.switchCaseLabels_return preCases = null;

        JavaParser.switchCaseLabels_return postCases = null;

        JavaParser.switchDefaultLabel_return switchDefaultLabel346 = null;


        RewriteRuleSubtreeStream stream_switchDefaultLabel = new RewriteRuleSubtreeStream(adaptor, "rule switchDefaultLabel");
        RewriteRuleSubtreeStream stream_switchCaseLabels = new RewriteRuleSubtreeStream(adaptor, "rule switchCaseLabels");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 79))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:886:5: (preCases= switchCaseLabels ( switchDefaultLabel )? postCases= switchCaseLabels -> ^( SWITCH_BLOCK_LABEL_LIST ( $preCases)? ( switchDefaultLabel )? ( $postCases)? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:886:9: preCases= switchCaseLabels ( switchDefaultLabel )? postCases= switchCaseLabels
            {
                pushFollow(FOLLOW_switchCaseLabels_in_switchBlockLabels9838);
                preCases = switchCaseLabels();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_switchCaseLabels.add(preCases.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:886:35: ( switchDefaultLabel )?
                int alt100 = 2;
                int LA100_0 = input.LA(1);

                if ((LA100_0 == DEFAULT))
                {
                    alt100 = 1;
                }
                switch (alt100)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: switchDefaultLabel
                    {
                        pushFollow(FOLLOW_switchDefaultLabel_in_switchBlockLabels9840);
                        switchDefaultLabel346 = switchDefaultLabel();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_switchDefaultLabel.add(switchDefaultLabel346.getTree());

                    }
                    break;

                }

                pushFollow(FOLLOW_switchCaseLabels_in_switchBlockLabels9845);
                postCases = switchCaseLabels();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_switchCaseLabels.add(postCases.getTree());


                // AST REWRITE
                // elements: postCases, preCases, switchDefaultLabel
                // token labels:
                // rule labels: retval, preCases, postCases
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                    RewriteRuleSubtreeStream stream_preCases = new RewriteRuleSubtreeStream(adaptor, "rule preCases", preCases != null ? preCases.tree : null);
                    RewriteRuleSubtreeStream stream_postCases = new RewriteRuleSubtreeStream(adaptor, "rule postCases", postCases != null ? postCases.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 887:9: -> ^( SWITCH_BLOCK_LABEL_LIST ( $preCases)? ( switchDefaultLabel )? ( $postCases)? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:887:13: ^( SWITCH_BLOCK_LABEL_LIST ( $preCases)? ( switchDefaultLabel )? ( $postCases)? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(SWITCH_BLOCK_LABEL_LIST, "SWITCH_BLOCK_LABEL_LIST"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:887:39: ( $preCases)?
                            if (stream_preCases.hasNext())
                            {
                                adaptor.addChild(root_1, stream_preCases.nextTree());

                            }
                            stream_preCases.reset();
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:887:50: ( switchDefaultLabel )?
                            if (stream_switchDefaultLabel.hasNext())
                            {
                                adaptor.addChild(root_1, stream_switchDefaultLabel.nextTree());

                            }
                            stream_switchDefaultLabel.reset();
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:887:70: ( $postCases)?
                            if (stream_postCases.hasNext())
                            {
                                adaptor.addChild(root_1, stream_postCases.nextTree());

                            }
                            stream_postCases.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 79, switchBlockLabels_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "switchBlockLabels"

    public static class switchCaseLabels_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "switchCaseLabels"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:890:1: switchCaseLabels : ( switchCaseLabel )* ;

    public final JavaParser.switchCaseLabels_return switchCaseLabels() throws RecognitionException
    {
        JavaParser.switchCaseLabels_return retval = new JavaParser.switchCaseLabels_return();
        retval.start = input.LT(1);
        int switchCaseLabels_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.switchCaseLabel_return switchCaseLabel347 = null;


        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 80))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:891:5: ( ( switchCaseLabel )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:891:9: ( switchCaseLabel )*
            {
                root_0 = (CommonTree) adaptor.nil();

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:891:9: ( switchCaseLabel )*
                loop101:
                do
                {
                    int alt101 = 2;
                    int LA101_0 = input.LA(1);

                    if ((LA101_0 == CASE))
                    {
                        int LA101_2 = input.LA(2);

                        if ((synpred144_Java()))
                        {
                            alt101 = 1;
                        }


                    }


                    switch (alt101)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: switchCaseLabel
                        {
                            pushFollow(FOLLOW_switchCaseLabel_in_switchCaseLabels9890);
                            switchCaseLabel347 = switchCaseLabel();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, switchCaseLabel347.getTree());

                        }
                        break;

                        default:
                            break loop101;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 80, switchCaseLabels_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "switchCaseLabels"

    public static class switchCaseLabel_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "switchCaseLabel"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:894:1: switchCaseLabel : CASE expression COLON ( blockStatement )* ;

    public final JavaParser.switchCaseLabel_return switchCaseLabel() throws RecognitionException
    {
        JavaParser.switchCaseLabel_return retval = new JavaParser.switchCaseLabel_return();
        retval.start = input.LT(1);
        int switchCaseLabel_StartIndex = input.index();
        CommonTree root_0 = null;

        Token CASE348 = null;
        Token COLON350 = null;
        JavaParser.expression_return expression349 = null;

        JavaParser.blockStatement_return blockStatement351 = null;


        CommonTree CASE348_tree = null;
        CommonTree COLON350_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 81))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:895:5: ( CASE expression COLON ( blockStatement )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:895:9: CASE expression COLON ( blockStatement )*
            {
                root_0 = (CommonTree) adaptor.nil();

                CASE348 = (Token) match(input, CASE, FOLLOW_CASE_in_switchCaseLabel9910);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    CASE348_tree = (CommonTree) adaptor.create(CASE348);
                    root_0 = (CommonTree) adaptor.becomeRoot(CASE348_tree, root_0);
                }
                pushFollow(FOLLOW_expression_in_switchCaseLabel9913);
                expression349 = expression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, expression349.getTree());
                COLON350 = (Token) match(input, COLON, FOLLOW_COLON_in_switchCaseLabel9915);
                if (state.failed) return retval;
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:895:33: ( blockStatement )*
                loop102:
                do
                {
                    int alt102 = 2;
                    int LA102_0 = input.LA(1);

                    if ((LA102_0 == AT || LA102_0 == DEC || LA102_0 == INC || LA102_0 == LCURLY || LA102_0 == LESS_THAN || LA102_0 == LOGICAL_NOT || (LA102_0 >= LPAREN && LA102_0 <= MINUS) || LA102_0 == NOT || LA102_0 == PLUS || LA102_0 == SEMI || (LA102_0 >= ABSTRACT && LA102_0 <= BYTE) || (LA102_0 >= CHAR && LA102_0 <= CONTINUE) || (LA102_0 >= DO && LA102_0 <= DOUBLE) || LA102_0 == ENUM || (LA102_0 >= FALSE && LA102_0 <= FINAL) || (LA102_0 >= FLOAT && LA102_0 <= IF) || LA102_0 == INTERFACE || (LA102_0 >= INT && LA102_0 <= NULL) || (LA102_0 >= PRIVATE && LA102_0 <= THROW) || (LA102_0 >= TRANSIENT && LA102_0 <= WHILE) || (LA102_0 >= IDENT && LA102_0 <= STRING_LITERAL)))
                    {
                        alt102 = 1;
                    }


                    switch (alt102)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: blockStatement
                        {
                            pushFollow(FOLLOW_blockStatement_in_switchCaseLabel9918);
                            blockStatement351 = blockStatement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, blockStatement351.getTree());

                        }
                        break;

                        default:
                            break loop102;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 81, switchCaseLabel_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "switchCaseLabel"

    public static class switchDefaultLabel_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "switchDefaultLabel"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:898:1: switchDefaultLabel : DEFAULT COLON ( blockStatement )* ;

    public final JavaParser.switchDefaultLabel_return switchDefaultLabel() throws RecognitionException
    {
        JavaParser.switchDefaultLabel_return retval = new JavaParser.switchDefaultLabel_return();
        retval.start = input.LT(1);
        int switchDefaultLabel_StartIndex = input.index();
        CommonTree root_0 = null;

        Token DEFAULT352 = null;
        Token COLON353 = null;
        JavaParser.blockStatement_return blockStatement354 = null;


        CommonTree DEFAULT352_tree = null;
        CommonTree COLON353_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 82))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:899:5: ( DEFAULT COLON ( blockStatement )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:899:9: DEFAULT COLON ( blockStatement )*
            {
                root_0 = (CommonTree) adaptor.nil();

                DEFAULT352 = (Token) match(input, DEFAULT, FOLLOW_DEFAULT_in_switchDefaultLabel9938);
                if (state.failed) return retval;
                if (state.backtracking == 0)
                {
                    DEFAULT352_tree = (CommonTree) adaptor.create(DEFAULT352);
                    root_0 = (CommonTree) adaptor.becomeRoot(DEFAULT352_tree, root_0);
                }
                COLON353 = (Token) match(input, COLON, FOLLOW_COLON_in_switchDefaultLabel9941);
                if (state.failed) return retval;
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:899:25: ( blockStatement )*
                loop103:
                do
                {
                    int alt103 = 2;
                    int LA103_0 = input.LA(1);

                    if ((LA103_0 == AT || LA103_0 == DEC || LA103_0 == INC || LA103_0 == LCURLY || LA103_0 == LESS_THAN || LA103_0 == LOGICAL_NOT || (LA103_0 >= LPAREN && LA103_0 <= MINUS) || LA103_0 == NOT || LA103_0 == PLUS || LA103_0 == SEMI || (LA103_0 >= ABSTRACT && LA103_0 <= BYTE) || (LA103_0 >= CHAR && LA103_0 <= CONTINUE) || (LA103_0 >= DO && LA103_0 <= DOUBLE) || LA103_0 == ENUM || (LA103_0 >= FALSE && LA103_0 <= FINAL) || (LA103_0 >= FLOAT && LA103_0 <= IF) || LA103_0 == INTERFACE || (LA103_0 >= INT && LA103_0 <= NULL) || (LA103_0 >= PRIVATE && LA103_0 <= THROW) || (LA103_0 >= TRANSIENT && LA103_0 <= WHILE) || (LA103_0 >= IDENT && LA103_0 <= STRING_LITERAL)))
                    {
                        alt103 = 1;
                    }


                    switch (alt103)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: blockStatement
                        {
                            pushFollow(FOLLOW_blockStatement_in_switchDefaultLabel9944);
                            blockStatement354 = blockStatement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, blockStatement354.getTree());

                        }
                        break;

                        default:
                            break loop103;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 82, switchDefaultLabel_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "switchDefaultLabel"

    public static class forInit_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "forInit"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:902:1: forInit : ( localVariableDeclaration -> ^( FOR_INIT localVariableDeclaration ) | expressionList -> ^( FOR_INIT expressionList ) | -> ^( FOR_INIT ) );

    public final JavaParser.forInit_return forInit() throws RecognitionException
    {
        JavaParser.forInit_return retval = new JavaParser.forInit_return();
        retval.start = input.LT(1);
        int forInit_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.localVariableDeclaration_return localVariableDeclaration355 = null;

        JavaParser.expressionList_return expressionList356 = null;


        RewriteRuleSubtreeStream stream_expressionList = new RewriteRuleSubtreeStream(adaptor, "rule expressionList");
        RewriteRuleSubtreeStream stream_localVariableDeclaration = new RewriteRuleSubtreeStream(adaptor, "rule localVariableDeclaration");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 83))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:903:5: ( localVariableDeclaration -> ^( FOR_INIT localVariableDeclaration ) | expressionList -> ^( FOR_INIT expressionList ) | -> ^( FOR_INIT ) )
            int alt104 = 3;
            alt104 = dfa104.predict(input);
            switch (alt104)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:903:9: localVariableDeclaration
                {
                    pushFollow(FOLLOW_localVariableDeclaration_in_forInit9964);
                    localVariableDeclaration355 = localVariableDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_localVariableDeclaration.add(localVariableDeclaration355.getTree());


                    // AST REWRITE
                    // elements: localVariableDeclaration
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 903:37: -> ^( FOR_INIT localVariableDeclaration )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:903:41: ^( FOR_INIT localVariableDeclaration )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FOR_INIT, "FOR_INIT"), root_1);

                                adaptor.addChild(root_1, stream_localVariableDeclaration.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:904:9: expressionList
                {
                    pushFollow(FOLLOW_expressionList_in_forInit9986);
                    expressionList356 = expressionList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_expressionList.add(expressionList356.getTree());


                    // AST REWRITE
                    // elements: expressionList
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 904:37: -> ^( FOR_INIT expressionList )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:904:41: ^( FOR_INIT expressionList )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FOR_INIT, "FOR_INIT"), root_1);

                                adaptor.addChild(root_1, stream_expressionList.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:905:37: 
                {

                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 905:37: -> ^( FOR_INIT )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:905:41: ^( FOR_INIT )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FOR_INIT, "FOR_INIT"), root_1);

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 83, forInit_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "forInit"

    public static class forCondition_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "forCondition"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:908:1: forCondition : ( expression )? -> ^( FOR_CONDITION ( expression )? ) ;

    public final JavaParser.forCondition_return forCondition() throws RecognitionException
    {
        JavaParser.forCondition_return retval = new JavaParser.forCondition_return();
        retval.start = input.LT(1);
        int forCondition_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.expression_return expression357 = null;


        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor, "rule expression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 84))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:909:5: ( ( expression )? -> ^( FOR_CONDITION ( expression )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:909:9: ( expression )?
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:909:9: ( expression )?
                int alt105 = 2;
                int LA105_0 = input.LA(1);

                if ((LA105_0 == DEC || LA105_0 == INC || LA105_0 == LESS_THAN || LA105_0 == LOGICAL_NOT || (LA105_0 >= LPAREN && LA105_0 <= MINUS) || LA105_0 == NOT || LA105_0 == PLUS || LA105_0 == BOOLEAN || LA105_0 == BYTE || LA105_0 == CHAR || LA105_0 == DOUBLE || LA105_0 == FALSE || LA105_0 == FLOAT || (LA105_0 >= INT && LA105_0 <= LONG) || (LA105_0 >= NEW && LA105_0 <= NULL) || LA105_0 == SHORT || LA105_0 == SUPER || LA105_0 == THIS || LA105_0 == TRUE || LA105_0 == VOID || (LA105_0 >= IDENT && LA105_0 <= STRING_LITERAL)))
                {
                    alt105 = 1;
                }
                switch (alt105)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: expression
                    {
                        pushFollow(FOLLOW_expression_in_forCondition10070);
                        expression357 = expression();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_expression.add(expression357.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: expression
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 910:9: -> ^( FOR_CONDITION ( expression )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:910:13: ^( FOR_CONDITION ( expression )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FOR_CONDITION, "FOR_CONDITION"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:910:29: ( expression )?
                            if (stream_expression.hasNext())
                            {
                                adaptor.addChild(root_1, stream_expression.nextTree());

                            }
                            stream_expression.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 84, forCondition_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "forCondition"

    public static class forUpdater_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "forUpdater"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:913:1: forUpdater : ( expressionList )? -> ^( FOR_UPDATE ( expressionList )? ) ;

    public final JavaParser.forUpdater_return forUpdater() throws RecognitionException
    {
        JavaParser.forUpdater_return retval = new JavaParser.forUpdater_return();
        retval.start = input.LT(1);
        int forUpdater_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.expressionList_return expressionList358 = null;


        RewriteRuleSubtreeStream stream_expressionList = new RewriteRuleSubtreeStream(adaptor, "rule expressionList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 85))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:914:5: ( ( expressionList )? -> ^( FOR_UPDATE ( expressionList )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:914:9: ( expressionList )?
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:914:9: ( expressionList )?
                int alt106 = 2;
                int LA106_0 = input.LA(1);

                if ((LA106_0 == DEC || LA106_0 == INC || LA106_0 == LESS_THAN || LA106_0 == LOGICAL_NOT || (LA106_0 >= LPAREN && LA106_0 <= MINUS) || LA106_0 == NOT || LA106_0 == PLUS || LA106_0 == BOOLEAN || LA106_0 == BYTE || LA106_0 == CHAR || LA106_0 == DOUBLE || LA106_0 == FALSE || LA106_0 == FLOAT || (LA106_0 >= INT && LA106_0 <= LONG) || (LA106_0 >= NEW && LA106_0 <= NULL) || LA106_0 == SHORT || LA106_0 == SUPER || LA106_0 == THIS || LA106_0 == TRUE || LA106_0 == VOID || (LA106_0 >= IDENT && LA106_0 <= STRING_LITERAL)))
                {
                    alt106 = 1;
                }
                switch (alt106)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: expressionList
                    {
                        pushFollow(FOLLOW_expressionList_in_forUpdater10108);
                        expressionList358 = expressionList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_expressionList.add(expressionList358.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: expressionList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 915:9: -> ^( FOR_UPDATE ( expressionList )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:915:13: ^( FOR_UPDATE ( expressionList )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(FOR_UPDATE, "FOR_UPDATE"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:915:26: ( expressionList )?
                            if (stream_expressionList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_expressionList.nextTree());

                            }
                            stream_expressionList.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 85, forUpdater_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "forUpdater"

    public static class parenthesizedExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "parenthesizedExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:920:1: parenthesizedExpression : LPAREN expression RPAREN -> ^( PARENTESIZED_EXPR[$LPAREN, \"PARENTESIZED_EXPR\"] expression ) ;

    public final JavaParser.parenthesizedExpression_return parenthesizedExpression() throws RecognitionException
    {
        JavaParser.parenthesizedExpression_return retval = new JavaParser.parenthesizedExpression_return();
        retval.start = input.LT(1);
        int parenthesizedExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LPAREN359 = null;
        Token RPAREN361 = null;
        JavaParser.expression_return expression360 = null;


        CommonTree LPAREN359_tree = null;
        CommonTree RPAREN361_tree = null;
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor, "rule expression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 86))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:921:5: ( LPAREN expression RPAREN -> ^( PARENTESIZED_EXPR[$LPAREN, \"PARENTESIZED_EXPR\"] expression ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:921:9: LPAREN expression RPAREN
            {
                LPAREN359 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_parenthesizedExpression10148);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LPAREN.add(LPAREN359);

                pushFollow(FOLLOW_expression_in_parenthesizedExpression10150);
                expression360 = expression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_expression.add(expression360.getTree());
                RPAREN361 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_parenthesizedExpression10152);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RPAREN.add(RPAREN361);


                // AST REWRITE
                // elements: expression
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 922:9: -> ^( PARENTESIZED_EXPR[$LPAREN, \"PARENTESIZED_EXPR\"] expression )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:922:13: ^( PARENTESIZED_EXPR[$LPAREN, \"PARENTESIZED_EXPR\"] expression )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(PARENTESIZED_EXPR, LPAREN359, "PARENTESIZED_EXPR"), root_1);

                            adaptor.addChild(root_1, stream_expression.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 86, parenthesizedExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "parenthesizedExpression"

    public static class expressionList_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "expressionList"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:925:1: expressionList : expression ( COMMA expression )* ;

    public final JavaParser.expressionList_return expressionList() throws RecognitionException
    {
        JavaParser.expressionList_return retval = new JavaParser.expressionList_return();
        retval.start = input.LT(1);
        int expressionList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token COMMA363 = null;
        JavaParser.expression_return expression362 = null;

        JavaParser.expression_return expression364 = null;


        CommonTree COMMA363_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 87))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:926:5: ( expression ( COMMA expression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:926:9: expression ( COMMA expression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_expression_in_expressionList10189);
                expression362 = expression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, expression362.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:926:20: ( COMMA expression )*
                loop107:
                do
                {
                    int alt107 = 2;
                    int LA107_0 = input.LA(1);

                    if ((LA107_0 == COMMA))
                    {
                        alt107 = 1;
                    }


                    switch (alt107)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:926:21: COMMA expression
                        {
                            COMMA363 = (Token) match(input, COMMA, FOLLOW_COMMA_in_expressionList10192);
                            if (state.failed) return retval;
                            pushFollow(FOLLOW_expression_in_expressionList10195);
                            expression364 = expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, expression364.getTree());

                        }
                        break;

                        default:
                            break loop107;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 87, expressionList_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "expressionList"

    public static class expression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "expression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:929:1: expression : assignmentExpression -> ^( EXPR assignmentExpression ) ;

    public final JavaParser.expression_return expression() throws RecognitionException
    {
        JavaParser.expression_return retval = new JavaParser.expression_return();
        retval.start = input.LT(1);
        int expression_StartIndex = input.index();
        CommonTree root_0 = null;

        JavaParser.assignmentExpression_return assignmentExpression365 = null;


        RewriteRuleSubtreeStream stream_assignmentExpression = new RewriteRuleSubtreeStream(adaptor, "rule assignmentExpression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 88))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:930:5: ( assignmentExpression -> ^( EXPR assignmentExpression ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:930:9: assignmentExpression
            {
                pushFollow(FOLLOW_assignmentExpression_in_expression10216);
                assignmentExpression365 = assignmentExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_assignmentExpression.add(assignmentExpression365.getTree());


                // AST REWRITE
                // elements: assignmentExpression
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 931:9: -> ^( EXPR assignmentExpression )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:931:13: ^( EXPR assignmentExpression )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(EXPR, "EXPR"), root_1);

                            adaptor.addChild(root_1, stream_assignmentExpression.nextTree());

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 88, expression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "expression"

    public static class assignmentExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "assignmentExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:934:1: assignmentExpression : conditionalExpression ( ( ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | STAR_ASSIGN | DIV_ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN | MOD_ASSIGN | SHIFT_LEFT_ASSIGN | SHIFT_RIGHT_ASSIGN | BIT_SHIFT_RIGHT_ASSIGN ) assignmentExpression )? ;

    public final JavaParser.assignmentExpression_return assignmentExpression() throws RecognitionException
    {
        JavaParser.assignmentExpression_return retval = new JavaParser.assignmentExpression_return();
        retval.start = input.LT(1);
        int assignmentExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ASSIGN367 = null;
        Token PLUS_ASSIGN368 = null;
        Token MINUS_ASSIGN369 = null;
        Token STAR_ASSIGN370 = null;
        Token DIV_ASSIGN371 = null;
        Token AND_ASSIGN372 = null;
        Token OR_ASSIGN373 = null;
        Token XOR_ASSIGN374 = null;
        Token MOD_ASSIGN375 = null;
        Token SHIFT_LEFT_ASSIGN376 = null;
        Token SHIFT_RIGHT_ASSIGN377 = null;
        Token BIT_SHIFT_RIGHT_ASSIGN378 = null;
        JavaParser.conditionalExpression_return conditionalExpression366 = null;

        JavaParser.assignmentExpression_return assignmentExpression379 = null;


        CommonTree ASSIGN367_tree = null;
        CommonTree PLUS_ASSIGN368_tree = null;
        CommonTree MINUS_ASSIGN369_tree = null;
        CommonTree STAR_ASSIGN370_tree = null;
        CommonTree DIV_ASSIGN371_tree = null;
        CommonTree AND_ASSIGN372_tree = null;
        CommonTree OR_ASSIGN373_tree = null;
        CommonTree XOR_ASSIGN374_tree = null;
        CommonTree MOD_ASSIGN375_tree = null;
        CommonTree SHIFT_LEFT_ASSIGN376_tree = null;
        CommonTree SHIFT_RIGHT_ASSIGN377_tree = null;
        CommonTree BIT_SHIFT_RIGHT_ASSIGN378_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 89))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:935:5: ( conditionalExpression ( ( ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | STAR_ASSIGN | DIV_ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN | MOD_ASSIGN | SHIFT_LEFT_ASSIGN | SHIFT_RIGHT_ASSIGN | BIT_SHIFT_RIGHT_ASSIGN ) assignmentExpression )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:935:9: conditionalExpression ( ( ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | STAR_ASSIGN | DIV_ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN | MOD_ASSIGN | SHIFT_LEFT_ASSIGN | SHIFT_RIGHT_ASSIGN | BIT_SHIFT_RIGHT_ASSIGN ) assignmentExpression )?
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_conditionalExpression_in_assignmentExpression10252);
                conditionalExpression366 = conditionalExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, conditionalExpression366.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:936:9: ( ( ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | STAR_ASSIGN | DIV_ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN | MOD_ASSIGN | SHIFT_LEFT_ASSIGN | SHIFT_RIGHT_ASSIGN | BIT_SHIFT_RIGHT_ASSIGN ) assignmentExpression )?
                int alt109 = 2;
                int LA109_0 = input.LA(1);

                if (((LA109_0 >= AND_ASSIGN && LA109_0 <= ASSIGN) || LA109_0 == BIT_SHIFT_RIGHT_ASSIGN || LA109_0 == DIV_ASSIGN || LA109_0 == MINUS_ASSIGN || LA109_0 == MOD_ASSIGN || LA109_0 == OR_ASSIGN || LA109_0 == PLUS_ASSIGN || LA109_0 == SHIFT_LEFT_ASSIGN || LA109_0 == SHIFT_RIGHT_ASSIGN || LA109_0 == STAR_ASSIGN || LA109_0 == XOR_ASSIGN))
                {
                    alt109 = 1;
                }
                switch (alt109)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:936:13: ( ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | STAR_ASSIGN | DIV_ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN | MOD_ASSIGN | SHIFT_LEFT_ASSIGN | SHIFT_RIGHT_ASSIGN | BIT_SHIFT_RIGHT_ASSIGN ) assignmentExpression
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:936:13: ( ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | STAR_ASSIGN | DIV_ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN | MOD_ASSIGN | SHIFT_LEFT_ASSIGN | SHIFT_RIGHT_ASSIGN | BIT_SHIFT_RIGHT_ASSIGN )
                        int alt108 = 12;
                        switch (input.LA(1))
                        {
                            case ASSIGN:
                            {
                                alt108 = 1;
                            }
                            break;
                            case PLUS_ASSIGN:
                            {
                                alt108 = 2;
                            }
                            break;
                            case MINUS_ASSIGN:
                            {
                                alt108 = 3;
                            }
                            break;
                            case STAR_ASSIGN:
                            {
                                alt108 = 4;
                            }
                            break;
                            case DIV_ASSIGN:
                            {
                                alt108 = 5;
                            }
                            break;
                            case AND_ASSIGN:
                            {
                                alt108 = 6;
                            }
                            break;
                            case OR_ASSIGN:
                            {
                                alt108 = 7;
                            }
                            break;
                            case XOR_ASSIGN:
                            {
                                alt108 = 8;
                            }
                            break;
                            case MOD_ASSIGN:
                            {
                                alt108 = 9;
                            }
                            break;
                            case SHIFT_LEFT_ASSIGN:
                            {
                                alt108 = 10;
                            }
                            break;
                            case SHIFT_RIGHT_ASSIGN:
                            {
                                alt108 = 11;
                            }
                            break;
                            case BIT_SHIFT_RIGHT_ASSIGN:
                            {
                                alt108 = 12;
                            }
                            break;
                            default:
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 108, 0, input);

                                throw nvae;
                        }

                        switch (alt108)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:936:17: ASSIGN
                            {
                                ASSIGN367 = (Token) match(input, ASSIGN, FOLLOW_ASSIGN_in_assignmentExpression10270);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    ASSIGN367_tree = (CommonTree) adaptor.create(ASSIGN367);
                                    root_0 = (CommonTree) adaptor.becomeRoot(ASSIGN367_tree, root_0);
                                }

                            }
                            break;
                            case 2:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:937:17: PLUS_ASSIGN
                            {
                                PLUS_ASSIGN368 = (Token) match(input, PLUS_ASSIGN, FOLLOW_PLUS_ASSIGN_in_assignmentExpression10289);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    PLUS_ASSIGN368_tree = (CommonTree) adaptor.create(PLUS_ASSIGN368);
                                    root_0 = (CommonTree) adaptor.becomeRoot(PLUS_ASSIGN368_tree, root_0);
                                }

                            }
                            break;
                            case 3:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:938:17: MINUS_ASSIGN
                            {
                                MINUS_ASSIGN369 = (Token) match(input, MINUS_ASSIGN, FOLLOW_MINUS_ASSIGN_in_assignmentExpression10308);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    MINUS_ASSIGN369_tree = (CommonTree) adaptor.create(MINUS_ASSIGN369);
                                    root_0 = (CommonTree) adaptor.becomeRoot(MINUS_ASSIGN369_tree, root_0);
                                }

                            }
                            break;
                            case 4:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:939:17: STAR_ASSIGN
                            {
                                STAR_ASSIGN370 = (Token) match(input, STAR_ASSIGN, FOLLOW_STAR_ASSIGN_in_assignmentExpression10327);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    STAR_ASSIGN370_tree = (CommonTree) adaptor.create(STAR_ASSIGN370);
                                    root_0 = (CommonTree) adaptor.becomeRoot(STAR_ASSIGN370_tree, root_0);
                                }

                            }
                            break;
                            case 5:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:940:17: DIV_ASSIGN
                            {
                                DIV_ASSIGN371 = (Token) match(input, DIV_ASSIGN, FOLLOW_DIV_ASSIGN_in_assignmentExpression10346);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    DIV_ASSIGN371_tree = (CommonTree) adaptor.create(DIV_ASSIGN371);
                                    root_0 = (CommonTree) adaptor.becomeRoot(DIV_ASSIGN371_tree, root_0);
                                }

                            }
                            break;
                            case 6:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:941:17: AND_ASSIGN
                            {
                                AND_ASSIGN372 = (Token) match(input, AND_ASSIGN, FOLLOW_AND_ASSIGN_in_assignmentExpression10365);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    AND_ASSIGN372_tree = (CommonTree) adaptor.create(AND_ASSIGN372);
                                    root_0 = (CommonTree) adaptor.becomeRoot(AND_ASSIGN372_tree, root_0);
                                }

                            }
                            break;
                            case 7:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:942:17: OR_ASSIGN
                            {
                                OR_ASSIGN373 = (Token) match(input, OR_ASSIGN, FOLLOW_OR_ASSIGN_in_assignmentExpression10384);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    OR_ASSIGN373_tree = (CommonTree) adaptor.create(OR_ASSIGN373);
                                    root_0 = (CommonTree) adaptor.becomeRoot(OR_ASSIGN373_tree, root_0);
                                }

                            }
                            break;
                            case 8:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:943:17: XOR_ASSIGN
                            {
                                XOR_ASSIGN374 = (Token) match(input, XOR_ASSIGN, FOLLOW_XOR_ASSIGN_in_assignmentExpression10403);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    XOR_ASSIGN374_tree = (CommonTree) adaptor.create(XOR_ASSIGN374);
                                    root_0 = (CommonTree) adaptor.becomeRoot(XOR_ASSIGN374_tree, root_0);
                                }

                            }
                            break;
                            case 9:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:944:17: MOD_ASSIGN
                            {
                                MOD_ASSIGN375 = (Token) match(input, MOD_ASSIGN, FOLLOW_MOD_ASSIGN_in_assignmentExpression10422);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    MOD_ASSIGN375_tree = (CommonTree) adaptor.create(MOD_ASSIGN375);
                                    root_0 = (CommonTree) adaptor.becomeRoot(MOD_ASSIGN375_tree, root_0);
                                }

                            }
                            break;
                            case 10:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:945:17: SHIFT_LEFT_ASSIGN
                            {
                                SHIFT_LEFT_ASSIGN376 = (Token) match(input, SHIFT_LEFT_ASSIGN, FOLLOW_SHIFT_LEFT_ASSIGN_in_assignmentExpression10441);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    SHIFT_LEFT_ASSIGN376_tree = (CommonTree) adaptor.create(SHIFT_LEFT_ASSIGN376);
                                    root_0 = (CommonTree) adaptor.becomeRoot(SHIFT_LEFT_ASSIGN376_tree, root_0);
                                }

                            }
                            break;
                            case 11:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:946:17: SHIFT_RIGHT_ASSIGN
                            {
                                SHIFT_RIGHT_ASSIGN377 = (Token) match(input, SHIFT_RIGHT_ASSIGN, FOLLOW_SHIFT_RIGHT_ASSIGN_in_assignmentExpression10460);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    SHIFT_RIGHT_ASSIGN377_tree = (CommonTree) adaptor.create(SHIFT_RIGHT_ASSIGN377);
                                    root_0 = (CommonTree) adaptor.becomeRoot(SHIFT_RIGHT_ASSIGN377_tree, root_0);
                                }

                            }
                            break;
                            case 12:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:947:17: BIT_SHIFT_RIGHT_ASSIGN
                            {
                                BIT_SHIFT_RIGHT_ASSIGN378 = (Token) match(input, BIT_SHIFT_RIGHT_ASSIGN, FOLLOW_BIT_SHIFT_RIGHT_ASSIGN_in_assignmentExpression10479);
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                {
                                    BIT_SHIFT_RIGHT_ASSIGN378_tree = (CommonTree) adaptor.create(BIT_SHIFT_RIGHT_ASSIGN378);
                                    root_0 = (CommonTree) adaptor.becomeRoot(BIT_SHIFT_RIGHT_ASSIGN378_tree, root_0);
                                }

                            }
                            break;

                        }

                        pushFollow(FOLLOW_assignmentExpression_in_assignmentExpression10500);
                        assignmentExpression379 = assignmentExpression();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, assignmentExpression379.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 89, assignmentExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "assignmentExpression"

    public static class conditionalExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "conditionalExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:952:1: conditionalExpression : logicalOrExpression ( QUESTION assignmentExpression COLON conditionalExpression )? ;

    public final JavaParser.conditionalExpression_return conditionalExpression() throws RecognitionException
    {
        JavaParser.conditionalExpression_return retval = new JavaParser.conditionalExpression_return();
        retval.start = input.LT(1);
        int conditionalExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token QUESTION381 = null;
        Token COLON383 = null;
        JavaParser.logicalOrExpression_return logicalOrExpression380 = null;

        JavaParser.assignmentExpression_return assignmentExpression382 = null;

        JavaParser.conditionalExpression_return conditionalExpression384 = null;


        CommonTree QUESTION381_tree = null;
        CommonTree COLON383_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 90))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:953:5: ( logicalOrExpression ( QUESTION assignmentExpression COLON conditionalExpression )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:953:9: logicalOrExpression ( QUESTION assignmentExpression COLON conditionalExpression )?
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_logicalOrExpression_in_conditionalExpression10521);
                logicalOrExpression380 = logicalOrExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, logicalOrExpression380.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:953:29: ( QUESTION assignmentExpression COLON conditionalExpression )?
                int alt110 = 2;
                int LA110_0 = input.LA(1);

                if ((LA110_0 == QUESTION))
                {
                    alt110 = 1;
                }
                switch (alt110)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:953:30: QUESTION assignmentExpression COLON conditionalExpression
                    {
                        QUESTION381 = (Token) match(input, QUESTION, FOLLOW_QUESTION_in_conditionalExpression10524);
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                        {
                            QUESTION381_tree = (CommonTree) adaptor.create(QUESTION381);
                            root_0 = (CommonTree) adaptor.becomeRoot(QUESTION381_tree, root_0);
                        }
                        pushFollow(FOLLOW_assignmentExpression_in_conditionalExpression10527);
                        assignmentExpression382 = assignmentExpression();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, assignmentExpression382.getTree());
                        COLON383 = (Token) match(input, COLON, FOLLOW_COLON_in_conditionalExpression10529);
                        if (state.failed) return retval;
                        pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression10532);
                        conditionalExpression384 = conditionalExpression();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, conditionalExpression384.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 90, conditionalExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "conditionalExpression"

    public static class logicalOrExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "logicalOrExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:956:1: logicalOrExpression : logicalAndExpression ( LOGICAL_OR logicalAndExpression )* ;

    public final JavaParser.logicalOrExpression_return logicalOrExpression() throws RecognitionException
    {
        JavaParser.logicalOrExpression_return retval = new JavaParser.logicalOrExpression_return();
        retval.start = input.LT(1);
        int logicalOrExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LOGICAL_OR386 = null;
        JavaParser.logicalAndExpression_return logicalAndExpression385 = null;

        JavaParser.logicalAndExpression_return logicalAndExpression387 = null;


        CommonTree LOGICAL_OR386_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 91))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:957:5: ( logicalAndExpression ( LOGICAL_OR logicalAndExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:957:9: logicalAndExpression ( LOGICAL_OR logicalAndExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_logicalAndExpression_in_logicalOrExpression10553);
                logicalAndExpression385 = logicalAndExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, logicalAndExpression385.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:957:30: ( LOGICAL_OR logicalAndExpression )*
                loop111:
                do
                {
                    int alt111 = 2;
                    int LA111_0 = input.LA(1);

                    if ((LA111_0 == LOGICAL_OR))
                    {
                        alt111 = 1;
                    }


                    switch (alt111)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:957:31: LOGICAL_OR logicalAndExpression
                        {
                            LOGICAL_OR386 = (Token) match(input, LOGICAL_OR, FOLLOW_LOGICAL_OR_in_logicalOrExpression10556);
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                            {
                                LOGICAL_OR386_tree = (CommonTree) adaptor.create(LOGICAL_OR386);
                                root_0 = (CommonTree) adaptor.becomeRoot(LOGICAL_OR386_tree, root_0);
                            }
                            pushFollow(FOLLOW_logicalAndExpression_in_logicalOrExpression10559);
                            logicalAndExpression387 = logicalAndExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, logicalAndExpression387.getTree());

                        }
                        break;

                        default:
                            break loop111;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 91, logicalOrExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "logicalOrExpression"

    public static class logicalAndExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "logicalAndExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:960:1: logicalAndExpression : inclusiveOrExpression ( LOGICAL_AND inclusiveOrExpression )* ;

    public final JavaParser.logicalAndExpression_return logicalAndExpression() throws RecognitionException
    {
        JavaParser.logicalAndExpression_return retval = new JavaParser.logicalAndExpression_return();
        retval.start = input.LT(1);
        int logicalAndExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LOGICAL_AND389 = null;
        JavaParser.inclusiveOrExpression_return inclusiveOrExpression388 = null;

        JavaParser.inclusiveOrExpression_return inclusiveOrExpression390 = null;


        CommonTree LOGICAL_AND389_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 92))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:961:5: ( inclusiveOrExpression ( LOGICAL_AND inclusiveOrExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:961:9: inclusiveOrExpression ( LOGICAL_AND inclusiveOrExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_inclusiveOrExpression_in_logicalAndExpression10580);
                inclusiveOrExpression388 = inclusiveOrExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, inclusiveOrExpression388.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:961:31: ( LOGICAL_AND inclusiveOrExpression )*
                loop112:
                do
                {
                    int alt112 = 2;
                    int LA112_0 = input.LA(1);

                    if ((LA112_0 == LOGICAL_AND))
                    {
                        alt112 = 1;
                    }


                    switch (alt112)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:961:32: LOGICAL_AND inclusiveOrExpression
                        {
                            LOGICAL_AND389 = (Token) match(input, LOGICAL_AND, FOLLOW_LOGICAL_AND_in_logicalAndExpression10583);
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                            {
                                LOGICAL_AND389_tree = (CommonTree) adaptor.create(LOGICAL_AND389);
                                root_0 = (CommonTree) adaptor.becomeRoot(LOGICAL_AND389_tree, root_0);
                            }
                            pushFollow(FOLLOW_inclusiveOrExpression_in_logicalAndExpression10586);
                            inclusiveOrExpression390 = inclusiveOrExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, inclusiveOrExpression390.getTree());

                        }
                        break;

                        default:
                            break loop112;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 92, logicalAndExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "logicalAndExpression"

    public static class inclusiveOrExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "inclusiveOrExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:964:1: inclusiveOrExpression : exclusiveOrExpression ( OR exclusiveOrExpression )* ;

    public final JavaParser.inclusiveOrExpression_return inclusiveOrExpression() throws RecognitionException
    {
        JavaParser.inclusiveOrExpression_return retval = new JavaParser.inclusiveOrExpression_return();
        retval.start = input.LT(1);
        int inclusiveOrExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token OR392 = null;
        JavaParser.exclusiveOrExpression_return exclusiveOrExpression391 = null;

        JavaParser.exclusiveOrExpression_return exclusiveOrExpression393 = null;


        CommonTree OR392_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 93))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:965:5: ( exclusiveOrExpression ( OR exclusiveOrExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:965:9: exclusiveOrExpression ( OR exclusiveOrExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression10607);
                exclusiveOrExpression391 = exclusiveOrExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, exclusiveOrExpression391.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:965:31: ( OR exclusiveOrExpression )*
                loop113:
                do
                {
                    int alt113 = 2;
                    int LA113_0 = input.LA(1);

                    if ((LA113_0 == OR))
                    {
                        alt113 = 1;
                    }


                    switch (alt113)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:965:32: OR exclusiveOrExpression
                        {
                            OR392 = (Token) match(input, OR, FOLLOW_OR_in_inclusiveOrExpression10610);
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                            {
                                OR392_tree = (CommonTree) adaptor.create(OR392);
                                root_0 = (CommonTree) adaptor.becomeRoot(OR392_tree, root_0);
                            }
                            pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression10613);
                            exclusiveOrExpression393 = exclusiveOrExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, exclusiveOrExpression393.getTree());

                        }
                        break;

                        default:
                            break loop113;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 93, inclusiveOrExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "inclusiveOrExpression"

    public static class exclusiveOrExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "exclusiveOrExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:968:1: exclusiveOrExpression : andExpression ( XOR andExpression )* ;

    public final JavaParser.exclusiveOrExpression_return exclusiveOrExpression() throws RecognitionException
    {
        JavaParser.exclusiveOrExpression_return retval = new JavaParser.exclusiveOrExpression_return();
        retval.start = input.LT(1);
        int exclusiveOrExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token XOR395 = null;
        JavaParser.andExpression_return andExpression394 = null;

        JavaParser.andExpression_return andExpression396 = null;


        CommonTree XOR395_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 94))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:969:5: ( andExpression ( XOR andExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:969:9: andExpression ( XOR andExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression10634);
                andExpression394 = andExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, andExpression394.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:969:23: ( XOR andExpression )*
                loop114:
                do
                {
                    int alt114 = 2;
                    int LA114_0 = input.LA(1);

                    if ((LA114_0 == XOR))
                    {
                        alt114 = 1;
                    }


                    switch (alt114)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:969:24: XOR andExpression
                        {
                            XOR395 = (Token) match(input, XOR, FOLLOW_XOR_in_exclusiveOrExpression10637);
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                            {
                                XOR395_tree = (CommonTree) adaptor.create(XOR395);
                                root_0 = (CommonTree) adaptor.becomeRoot(XOR395_tree, root_0);
                            }
                            pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression10640);
                            andExpression396 = andExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, andExpression396.getTree());

                        }
                        break;

                        default:
                            break loop114;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 94, exclusiveOrExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "exclusiveOrExpression"

    public static class andExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "andExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:972:1: andExpression : equalityExpression ( AND equalityExpression )* ;

    public final JavaParser.andExpression_return andExpression() throws RecognitionException
    {
        JavaParser.andExpression_return retval = new JavaParser.andExpression_return();
        retval.start = input.LT(1);
        int andExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token AND398 = null;
        JavaParser.equalityExpression_return equalityExpression397 = null;

        JavaParser.equalityExpression_return equalityExpression399 = null;


        CommonTree AND398_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 95))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:973:5: ( equalityExpression ( AND equalityExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:973:9: equalityExpression ( AND equalityExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_equalityExpression_in_andExpression10661);
                equalityExpression397 = equalityExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, equalityExpression397.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:973:28: ( AND equalityExpression )*
                loop115:
                do
                {
                    int alt115 = 2;
                    int LA115_0 = input.LA(1);

                    if ((LA115_0 == AND))
                    {
                        alt115 = 1;
                    }


                    switch (alt115)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:973:29: AND equalityExpression
                        {
                            AND398 = (Token) match(input, AND, FOLLOW_AND_in_andExpression10664);
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                            {
                                AND398_tree = (CommonTree) adaptor.create(AND398);
                                root_0 = (CommonTree) adaptor.becomeRoot(AND398_tree, root_0);
                            }
                            pushFollow(FOLLOW_equalityExpression_in_andExpression10667);
                            equalityExpression399 = equalityExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, equalityExpression399.getTree());

                        }
                        break;

                        default:
                            break loop115;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 95, andExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "andExpression"

    public static class equalityExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "equalityExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:976:1: equalityExpression : instanceOfExpression ( ( EQUAL | NOT_EQUAL ) instanceOfExpression )* ;

    public final JavaParser.equalityExpression_return equalityExpression() throws RecognitionException
    {
        JavaParser.equalityExpression_return retval = new JavaParser.equalityExpression_return();
        retval.start = input.LT(1);
        int equalityExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token EQUAL401 = null;
        Token NOT_EQUAL402 = null;
        JavaParser.instanceOfExpression_return instanceOfExpression400 = null;

        JavaParser.instanceOfExpression_return instanceOfExpression403 = null;


        CommonTree EQUAL401_tree = null;
        CommonTree NOT_EQUAL402_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 96))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:977:5: ( instanceOfExpression ( ( EQUAL | NOT_EQUAL ) instanceOfExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:977:9: instanceOfExpression ( ( EQUAL | NOT_EQUAL ) instanceOfExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression10688);
                instanceOfExpression400 = instanceOfExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, instanceOfExpression400.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:978:9: ( ( EQUAL | NOT_EQUAL ) instanceOfExpression )*
                loop117:
                do
                {
                    int alt117 = 2;
                    int LA117_0 = input.LA(1);

                    if ((LA117_0 == EQUAL || LA117_0 == NOT_EQUAL))
                    {
                        alt117 = 1;
                    }


                    switch (alt117)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:978:13: ( EQUAL | NOT_EQUAL ) instanceOfExpression
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:978:13: ( EQUAL | NOT_EQUAL )
                            int alt116 = 2;
                            int LA116_0 = input.LA(1);

                            if ((LA116_0 == EQUAL))
                            {
                                alt116 = 1;
                            }
                            else if ((LA116_0 == NOT_EQUAL))
                            {
                                alt116 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 116, 0, input);

                                throw nvae;
                            }
                            switch (alt116)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:978:17: EQUAL
                                {
                                    EQUAL401 = (Token) match(input, EQUAL, FOLLOW_EQUAL_in_equalityExpression10706);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        EQUAL401_tree = (CommonTree) adaptor.create(EQUAL401);
                                        root_0 = (CommonTree) adaptor.becomeRoot(EQUAL401_tree, root_0);
                                    }

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:979:17: NOT_EQUAL
                                {
                                    NOT_EQUAL402 = (Token) match(input, NOT_EQUAL, FOLLOW_NOT_EQUAL_in_equalityExpression10725);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        NOT_EQUAL402_tree = (CommonTree) adaptor.create(NOT_EQUAL402);
                                        root_0 = (CommonTree) adaptor.becomeRoot(NOT_EQUAL402_tree, root_0);
                                    }

                                }
                                break;

                            }

                            pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression10754);
                            instanceOfExpression403 = instanceOfExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, instanceOfExpression403.getTree());

                        }
                        break;

                        default:
                            break loop117;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 96, equalityExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "equalityExpression"

    public static class instanceOfExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "instanceOfExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:985:1: instanceOfExpression : relationalExpression ( INSTANCEOF type )? ;

    public final JavaParser.instanceOfExpression_return instanceOfExpression() throws RecognitionException
    {
        JavaParser.instanceOfExpression_return retval = new JavaParser.instanceOfExpression_return();
        retval.start = input.LT(1);
        int instanceOfExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token INSTANCEOF405 = null;
        JavaParser.relationalExpression_return relationalExpression404 = null;

        JavaParser.type_return type406 = null;


        CommonTree INSTANCEOF405_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 97))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:986:5: ( relationalExpression ( INSTANCEOF type )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:986:9: relationalExpression ( INSTANCEOF type )?
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression10784);
                relationalExpression404 = relationalExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, relationalExpression404.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:986:30: ( INSTANCEOF type )?
                int alt118 = 2;
                int LA118_0 = input.LA(1);

                if ((LA118_0 == INSTANCEOF))
                {
                    alt118 = 1;
                }
                switch (alt118)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:986:31: INSTANCEOF type
                    {
                        INSTANCEOF405 = (Token) match(input, INSTANCEOF, FOLLOW_INSTANCEOF_in_instanceOfExpression10787);
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                        {
                            INSTANCEOF405_tree = (CommonTree) adaptor.create(INSTANCEOF405);
                            root_0 = (CommonTree) adaptor.becomeRoot(INSTANCEOF405_tree, root_0);
                        }
                        pushFollow(FOLLOW_type_in_instanceOfExpression10790);
                        type406 = type();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) adaptor.addChild(root_0, type406.getTree());

                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 97, instanceOfExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "instanceOfExpression"

    public static class relationalExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "relationalExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:989:1: relationalExpression : shiftExpression ( ( LESS_OR_EQUAL | GREATER_OR_EQUAL | LESS_THAN | GREATER_THAN ) shiftExpression )* ;

    public final JavaParser.relationalExpression_return relationalExpression() throws RecognitionException
    {
        JavaParser.relationalExpression_return retval = new JavaParser.relationalExpression_return();
        retval.start = input.LT(1);
        int relationalExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LESS_OR_EQUAL408 = null;
        Token GREATER_OR_EQUAL409 = null;
        Token LESS_THAN410 = null;
        Token GREATER_THAN411 = null;
        JavaParser.shiftExpression_return shiftExpression407 = null;

        JavaParser.shiftExpression_return shiftExpression412 = null;


        CommonTree LESS_OR_EQUAL408_tree = null;
        CommonTree GREATER_OR_EQUAL409_tree = null;
        CommonTree LESS_THAN410_tree = null;
        CommonTree GREATER_THAN411_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 98))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:990:5: ( shiftExpression ( ( LESS_OR_EQUAL | GREATER_OR_EQUAL | LESS_THAN | GREATER_THAN ) shiftExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:990:9: shiftExpression ( ( LESS_OR_EQUAL | GREATER_OR_EQUAL | LESS_THAN | GREATER_THAN ) shiftExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_shiftExpression_in_relationalExpression10811);
                shiftExpression407 = shiftExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, shiftExpression407.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:991:9: ( ( LESS_OR_EQUAL | GREATER_OR_EQUAL | LESS_THAN | GREATER_THAN ) shiftExpression )*
                loop120:
                do
                {
                    int alt120 = 2;
                    int LA120_0 = input.LA(1);

                    if (((LA120_0 >= GREATER_OR_EQUAL && LA120_0 <= GREATER_THAN) || (LA120_0 >= LESS_OR_EQUAL && LA120_0 <= LESS_THAN)))
                    {
                        alt120 = 1;
                    }


                    switch (alt120)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:991:13: ( LESS_OR_EQUAL | GREATER_OR_EQUAL | LESS_THAN | GREATER_THAN ) shiftExpression
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:991:13: ( LESS_OR_EQUAL | GREATER_OR_EQUAL | LESS_THAN | GREATER_THAN )
                            int alt119 = 4;
                            switch (input.LA(1))
                            {
                                case LESS_OR_EQUAL:
                                {
                                    alt119 = 1;
                                }
                                break;
                                case GREATER_OR_EQUAL:
                                {
                                    alt119 = 2;
                                }
                                break;
                                case LESS_THAN:
                                {
                                    alt119 = 3;
                                }
                                break;
                                case GREATER_THAN:
                                {
                                    alt119 = 4;
                                }
                                break;
                                default:
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    NoViableAltException nvae =
                                            new NoViableAltException("", 119, 0, input);

                                    throw nvae;
                            }

                            switch (alt119)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:991:17: LESS_OR_EQUAL
                                {
                                    LESS_OR_EQUAL408 = (Token) match(input, LESS_OR_EQUAL, FOLLOW_LESS_OR_EQUAL_in_relationalExpression10829);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        LESS_OR_EQUAL408_tree = (CommonTree) adaptor.create(LESS_OR_EQUAL408);
                                        root_0 = (CommonTree) adaptor.becomeRoot(LESS_OR_EQUAL408_tree, root_0);
                                    }

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:992:17: GREATER_OR_EQUAL
                                {
                                    GREATER_OR_EQUAL409 = (Token) match(input, GREATER_OR_EQUAL, FOLLOW_GREATER_OR_EQUAL_in_relationalExpression10848);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        GREATER_OR_EQUAL409_tree = (CommonTree) adaptor.create(GREATER_OR_EQUAL409);
                                        root_0 = (CommonTree) adaptor.becomeRoot(GREATER_OR_EQUAL409_tree, root_0);
                                    }

                                }
                                break;
                                case 3:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:993:17: LESS_THAN
                                {
                                    LESS_THAN410 = (Token) match(input, LESS_THAN, FOLLOW_LESS_THAN_in_relationalExpression10867);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        LESS_THAN410_tree = (CommonTree) adaptor.create(LESS_THAN410);
                                        root_0 = (CommonTree) adaptor.becomeRoot(LESS_THAN410_tree, root_0);
                                    }

                                }
                                break;
                                case 4:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:994:17: GREATER_THAN
                                {
                                    GREATER_THAN411 = (Token) match(input, GREATER_THAN, FOLLOW_GREATER_THAN_in_relationalExpression10886);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        GREATER_THAN411_tree = (CommonTree) adaptor.create(GREATER_THAN411);
                                        root_0 = (CommonTree) adaptor.becomeRoot(GREATER_THAN411_tree, root_0);
                                    }

                                }
                                break;

                            }

                            pushFollow(FOLLOW_shiftExpression_in_relationalExpression10915);
                            shiftExpression412 = shiftExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, shiftExpression412.getTree());

                        }
                        break;

                        default:
                            break loop120;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 98, relationalExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "relationalExpression"

    public static class shiftExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "shiftExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1000:1: shiftExpression : additiveExpression ( ( BIT_SHIFT_RIGHT | SHIFT_RIGHT | SHIFT_LEFT ) additiveExpression )* ;

    public final JavaParser.shiftExpression_return shiftExpression() throws RecognitionException
    {
        JavaParser.shiftExpression_return retval = new JavaParser.shiftExpression_return();
        retval.start = input.LT(1);
        int shiftExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token BIT_SHIFT_RIGHT414 = null;
        Token SHIFT_RIGHT415 = null;
        Token SHIFT_LEFT416 = null;
        JavaParser.additiveExpression_return additiveExpression413 = null;

        JavaParser.additiveExpression_return additiveExpression417 = null;


        CommonTree BIT_SHIFT_RIGHT414_tree = null;
        CommonTree SHIFT_RIGHT415_tree = null;
        CommonTree SHIFT_LEFT416_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 99))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1001:5: ( additiveExpression ( ( BIT_SHIFT_RIGHT | SHIFT_RIGHT | SHIFT_LEFT ) additiveExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1001:9: additiveExpression ( ( BIT_SHIFT_RIGHT | SHIFT_RIGHT | SHIFT_LEFT ) additiveExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_additiveExpression_in_shiftExpression10945);
                additiveExpression413 = additiveExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, additiveExpression413.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1002:9: ( ( BIT_SHIFT_RIGHT | SHIFT_RIGHT | SHIFT_LEFT ) additiveExpression )*
                loop122:
                do
                {
                    int alt122 = 2;
                    int LA122_0 = input.LA(1);

                    if ((LA122_0 == BIT_SHIFT_RIGHT || LA122_0 == SHIFT_LEFT || LA122_0 == SHIFT_RIGHT))
                    {
                        alt122 = 1;
                    }


                    switch (alt122)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1002:13: ( BIT_SHIFT_RIGHT | SHIFT_RIGHT | SHIFT_LEFT ) additiveExpression
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1002:13: ( BIT_SHIFT_RIGHT | SHIFT_RIGHT | SHIFT_LEFT )
                            int alt121 = 3;
                            switch (input.LA(1))
                            {
                                case BIT_SHIFT_RIGHT:
                                {
                                    alt121 = 1;
                                }
                                break;
                                case SHIFT_RIGHT:
                                {
                                    alt121 = 2;
                                }
                                break;
                                case SHIFT_LEFT:
                                {
                                    alt121 = 3;
                                }
                                break;
                                default:
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    NoViableAltException nvae =
                                            new NoViableAltException("", 121, 0, input);

                                    throw nvae;
                            }

                            switch (alt121)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1002:17: BIT_SHIFT_RIGHT
                                {
                                    BIT_SHIFT_RIGHT414 = (Token) match(input, BIT_SHIFT_RIGHT, FOLLOW_BIT_SHIFT_RIGHT_in_shiftExpression10963);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        BIT_SHIFT_RIGHT414_tree = (CommonTree) adaptor.create(BIT_SHIFT_RIGHT414);
                                        root_0 = (CommonTree) adaptor.becomeRoot(BIT_SHIFT_RIGHT414_tree, root_0);
                                    }

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1003:17: SHIFT_RIGHT
                                {
                                    SHIFT_RIGHT415 = (Token) match(input, SHIFT_RIGHT, FOLLOW_SHIFT_RIGHT_in_shiftExpression10982);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        SHIFT_RIGHT415_tree = (CommonTree) adaptor.create(SHIFT_RIGHT415);
                                        root_0 = (CommonTree) adaptor.becomeRoot(SHIFT_RIGHT415_tree, root_0);
                                    }

                                }
                                break;
                                case 3:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1004:17: SHIFT_LEFT
                                {
                                    SHIFT_LEFT416 = (Token) match(input, SHIFT_LEFT, FOLLOW_SHIFT_LEFT_in_shiftExpression11001);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        SHIFT_LEFT416_tree = (CommonTree) adaptor.create(SHIFT_LEFT416);
                                        root_0 = (CommonTree) adaptor.becomeRoot(SHIFT_LEFT416_tree, root_0);
                                    }

                                }
                                break;

                            }

                            pushFollow(FOLLOW_additiveExpression_in_shiftExpression11030);
                            additiveExpression417 = additiveExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, additiveExpression417.getTree());

                        }
                        break;

                        default:
                            break loop122;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 99, shiftExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "shiftExpression"

    public static class additiveExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "additiveExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1010:1: additiveExpression : multiplicativeExpression ( ( PLUS | MINUS ) multiplicativeExpression )* ;

    public final JavaParser.additiveExpression_return additiveExpression() throws RecognitionException
    {
        JavaParser.additiveExpression_return retval = new JavaParser.additiveExpression_return();
        retval.start = input.LT(1);
        int additiveExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token PLUS419 = null;
        Token MINUS420 = null;
        JavaParser.multiplicativeExpression_return multiplicativeExpression418 = null;

        JavaParser.multiplicativeExpression_return multiplicativeExpression421 = null;


        CommonTree PLUS419_tree = null;
        CommonTree MINUS420_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 100))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1011:5: ( multiplicativeExpression ( ( PLUS | MINUS ) multiplicativeExpression )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1011:9: multiplicativeExpression ( ( PLUS | MINUS ) multiplicativeExpression )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression11060);
                multiplicativeExpression418 = multiplicativeExpression();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, multiplicativeExpression418.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1012:9: ( ( PLUS | MINUS ) multiplicativeExpression )*
                loop124:
                do
                {
                    int alt124 = 2;
                    int LA124_0 = input.LA(1);

                    if ((LA124_0 == MINUS || LA124_0 == PLUS))
                    {
                        alt124 = 1;
                    }


                    switch (alt124)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1012:13: ( PLUS | MINUS ) multiplicativeExpression
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1012:13: ( PLUS | MINUS )
                            int alt123 = 2;
                            int LA123_0 = input.LA(1);

                            if ((LA123_0 == PLUS))
                            {
                                alt123 = 1;
                            }
                            else if ((LA123_0 == MINUS))
                            {
                                alt123 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 123, 0, input);

                                throw nvae;
                            }
                            switch (alt123)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1012:17: PLUS
                                {
                                    PLUS419 = (Token) match(input, PLUS, FOLLOW_PLUS_in_additiveExpression11078);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        PLUS419_tree = (CommonTree) adaptor.create(PLUS419);
                                        root_0 = (CommonTree) adaptor.becomeRoot(PLUS419_tree, root_0);
                                    }

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1013:17: MINUS
                                {
                                    MINUS420 = (Token) match(input, MINUS, FOLLOW_MINUS_in_additiveExpression11097);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        MINUS420_tree = (CommonTree) adaptor.create(MINUS420);
                                        root_0 = (CommonTree) adaptor.becomeRoot(MINUS420_tree, root_0);
                                    }

                                }
                                break;

                            }

                            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression11126);
                            multiplicativeExpression421 = multiplicativeExpression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0)
                                adaptor.addChild(root_0, multiplicativeExpression421.getTree());

                        }
                        break;

                        default:
                            break loop124;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 100, additiveExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "additiveExpression"

    public static class multiplicativeExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "multiplicativeExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1019:1: multiplicativeExpression : unaryExpressionAll ( ( STAR | DIV | MOD ) unaryExpressionAll )* ;

    public final JavaParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException
    {
        JavaParser.multiplicativeExpression_return retval = new JavaParser.multiplicativeExpression_return();
        retval.start = input.LT(1);
        int multiplicativeExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token STAR423 = null;
        Token DIV424 = null;
        Token MOD425 = null;
        JavaParser.unaryExpressionAll_return unaryExpressionAll422 = null;

        JavaParser.unaryExpressionAll_return unaryExpressionAll426 = null;


        CommonTree STAR423_tree = null;
        CommonTree DIV424_tree = null;
        CommonTree MOD425_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 101))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1020:5: ( unaryExpressionAll ( ( STAR | DIV | MOD ) unaryExpressionAll )* )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1020:9: unaryExpressionAll ( ( STAR | DIV | MOD ) unaryExpressionAll )*
            {
                root_0 = (CommonTree) adaptor.nil();

                pushFollow(FOLLOW_unaryExpressionAll_in_multiplicativeExpression11156);
                unaryExpressionAll422 = unaryExpressionAll();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) adaptor.addChild(root_0, unaryExpressionAll422.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1021:9: ( ( STAR | DIV | MOD ) unaryExpressionAll )*
                loop126:
                do
                {
                    int alt126 = 2;
                    int LA126_0 = input.LA(1);

                    if ((LA126_0 == DIV || LA126_0 == MOD || LA126_0 == STAR))
                    {
                        alt126 = 1;
                    }


                    switch (alt126)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1021:13: ( STAR | DIV | MOD ) unaryExpressionAll
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1021:13: ( STAR | DIV | MOD )
                            int alt125 = 3;
                            switch (input.LA(1))
                            {
                                case STAR:
                                {
                                    alt125 = 1;
                                }
                                break;
                                case DIV:
                                {
                                    alt125 = 2;
                                }
                                break;
                                case MOD:
                                {
                                    alt125 = 3;
                                }
                                break;
                                default:
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    NoViableAltException nvae =
                                            new NoViableAltException("", 125, 0, input);

                                    throw nvae;
                            }

                            switch (alt125)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1021:17: STAR
                                {
                                    STAR423 = (Token) match(input, STAR, FOLLOW_STAR_in_multiplicativeExpression11174);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        STAR423_tree = (CommonTree) adaptor.create(STAR423);
                                        root_0 = (CommonTree) adaptor.becomeRoot(STAR423_tree, root_0);
                                    }

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1022:17: DIV
                                {
                                    DIV424 = (Token) match(input, DIV, FOLLOW_DIV_in_multiplicativeExpression11193);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        DIV424_tree = (CommonTree) adaptor.create(DIV424);
                                        root_0 = (CommonTree) adaptor.becomeRoot(DIV424_tree, root_0);
                                    }

                                }
                                break;
                                case 3:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1023:17: MOD
                                {
                                    MOD425 = (Token) match(input, MOD, FOLLOW_MOD_in_multiplicativeExpression11212);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                    {
                                        MOD425_tree = (CommonTree) adaptor.create(MOD425);
                                        root_0 = (CommonTree) adaptor.becomeRoot(MOD425_tree, root_0);
                                    }

                                }
                                break;

                            }

                            pushFollow(FOLLOW_unaryExpressionAll_in_multiplicativeExpression11241);
                            unaryExpressionAll426 = unaryExpressionAll();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, unaryExpressionAll426.getTree());

                        }
                        break;

                        default:
                            break loop126;
                    }
                }
                while (true);


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 101, multiplicativeExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"

    public static class unaryExpressionAll_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "unaryExpressionAll"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1029:1: unaryExpressionAll : ( PLUS unaryExpressionAll -> ^( UNARY_PLUS[$PLUS, \"UNARY_PLUS\"] unaryExpressionAll ) | MINUS unaryExpressionAll -> ^( UNARY_MINUS[$MINUS, \"UNARY_MINUS\"] unaryExpressionAll ) | INC postfixedExpression -> ^( PRE_INC[$INC, \"PRE_INC\"] postfixedExpression ) | DEC postfixedExpression -> ^( PRE_DEC[$DEC, \"PRE_DEC\"] postfixedExpression ) | unaryExpressionRest );

    public final JavaParser.unaryExpressionAll_return unaryExpressionAll() throws RecognitionException
    {
        JavaParser.unaryExpressionAll_return retval = new JavaParser.unaryExpressionAll_return();
        retval.start = input.LT(1);
        int unaryExpressionAll_StartIndex = input.index();
        CommonTree root_0 = null;

        Token PLUS427 = null;
        Token MINUS429 = null;
        Token INC431 = null;
        Token DEC433 = null;
        JavaParser.unaryExpressionAll_return unaryExpressionAll428 = null;

        JavaParser.unaryExpressionAll_return unaryExpressionAll430 = null;

        JavaParser.postfixedExpression_return postfixedExpression432 = null;

        JavaParser.postfixedExpression_return postfixedExpression434 = null;

        JavaParser.unaryExpressionRest_return unaryExpressionRest435 = null;


        CommonTree PLUS427_tree = null;
        CommonTree MINUS429_tree = null;
        CommonTree INC431_tree = null;
        CommonTree DEC433_tree = null;
        RewriteRuleTokenStream stream_DEC = new RewriteRuleTokenStream(adaptor, "token DEC");
        RewriteRuleTokenStream stream_INC = new RewriteRuleTokenStream(adaptor, "token INC");
        RewriteRuleTokenStream stream_PLUS = new RewriteRuleTokenStream(adaptor, "token PLUS");
        RewriteRuleTokenStream stream_MINUS = new RewriteRuleTokenStream(adaptor, "token MINUS");
        RewriteRuleSubtreeStream stream_postfixedExpression = new RewriteRuleSubtreeStream(adaptor, "rule postfixedExpression");
        RewriteRuleSubtreeStream stream_unaryExpressionAll = new RewriteRuleSubtreeStream(adaptor, "rule unaryExpressionAll");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 102))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1030:5: ( PLUS unaryExpressionAll -> ^( UNARY_PLUS[$PLUS, \"UNARY_PLUS\"] unaryExpressionAll ) | MINUS unaryExpressionAll -> ^( UNARY_MINUS[$MINUS, \"UNARY_MINUS\"] unaryExpressionAll ) | INC postfixedExpression -> ^( PRE_INC[$INC, \"PRE_INC\"] postfixedExpression ) | DEC postfixedExpression -> ^( PRE_DEC[$DEC, \"PRE_DEC\"] postfixedExpression ) | unaryExpressionRest )
            int alt127 = 5;
            switch (input.LA(1))
            {
                case PLUS:
                {
                    alt127 = 1;
                }
                break;
                case MINUS:
                {
                    alt127 = 2;
                }
                break;
                case INC:
                {
                    alt127 = 3;
                }
                break;
                case DEC:
                {
                    alt127 = 4;
                }
                break;
                case LESS_THAN:
                case LOGICAL_NOT:
                case LPAREN:
                case NOT:
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FALSE:
                case FLOAT:
                case INT:
                case LONG:
                case NEW:
                case NULL:
                case SHORT:
                case SUPER:
                case THIS:
                case TRUE:
                case VOID:
                case IDENT:
                case HEX_LITERAL:
                case OCTAL_LITERAL:
                case DECIMAL_LITERAL:
                case FLOATING_POINT_LITERAL:
                case CHARACTER_LITERAL:
                case STRING_LITERAL:
                {
                    alt127 = 5;
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 127, 0, input);

                    throw nvae;
            }

            switch (alt127)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1030:9: PLUS unaryExpressionAll
                {
                    PLUS427 = (Token) match(input, PLUS, FOLLOW_PLUS_in_unaryExpressionAll11271);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_PLUS.add(PLUS427);

                    pushFollow(FOLLOW_unaryExpressionAll_in_unaryExpressionAll11273);
                    unaryExpressionAll428 = unaryExpressionAll();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_unaryExpressionAll.add(unaryExpressionAll428.getTree());


                    // AST REWRITE
                    // elements: unaryExpressionAll
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1030:37: -> ^( UNARY_PLUS[$PLUS, \"UNARY_PLUS\"] unaryExpressionAll )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1030:41: ^( UNARY_PLUS[$PLUS, \"UNARY_PLUS\"] unaryExpressionAll )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(UNARY_PLUS, PLUS427, "UNARY_PLUS"), root_1);

                                adaptor.addChild(root_1, stream_unaryExpressionAll.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1031:9: MINUS unaryExpressionAll
                {
                    MINUS429 = (Token) match(input, MINUS, FOLLOW_MINUS_in_unaryExpressionAll11297);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_MINUS.add(MINUS429);

                    pushFollow(FOLLOW_unaryExpressionAll_in_unaryExpressionAll11299);
                    unaryExpressionAll430 = unaryExpressionAll();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_unaryExpressionAll.add(unaryExpressionAll430.getTree());


                    // AST REWRITE
                    // elements: unaryExpressionAll
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1031:37: -> ^( UNARY_MINUS[$MINUS, \"UNARY_MINUS\"] unaryExpressionAll )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1031:41: ^( UNARY_MINUS[$MINUS, \"UNARY_MINUS\"] unaryExpressionAll )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(UNARY_MINUS, MINUS429, "UNARY_MINUS"), root_1);

                                adaptor.addChild(root_1, stream_unaryExpressionAll.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1032:9: INC postfixedExpression
                {
                    INC431 = (Token) match(input, INC, FOLLOW_INC_in_unaryExpressionAll11322);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_INC.add(INC431);

                    pushFollow(FOLLOW_postfixedExpression_in_unaryExpressionAll11324);
                    postfixedExpression432 = postfixedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_postfixedExpression.add(postfixedExpression432.getTree());


                    // AST REWRITE
                    // elements: postfixedExpression
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1032:37: -> ^( PRE_INC[$INC, \"PRE_INC\"] postfixedExpression )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1032:41: ^( PRE_INC[$INC, \"PRE_INC\"] postfixedExpression )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(PRE_INC, INC431, "PRE_INC"), root_1);

                                adaptor.addChild(root_1, stream_postfixedExpression.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1033:9: DEC postfixedExpression
                {
                    DEC433 = (Token) match(input, DEC, FOLLOW_DEC_in_unaryExpressionAll11348);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_DEC.add(DEC433);

                    pushFollow(FOLLOW_postfixedExpression_in_unaryExpressionAll11350);
                    postfixedExpression434 = postfixedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_postfixedExpression.add(postfixedExpression434.getTree());


                    // AST REWRITE
                    // elements: postfixedExpression
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1033:37: -> ^( PRE_DEC[$DEC, \"PRE_DEC\"] postfixedExpression )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1033:41: ^( PRE_DEC[$DEC, \"PRE_DEC\"] postfixedExpression )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(PRE_DEC, DEC433, "PRE_DEC"), root_1);

                                adaptor.addChild(root_1, stream_postfixedExpression.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1034:9: unaryExpressionRest
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_unaryExpressionRest_in_unaryExpressionAll11374);
                    unaryExpressionRest435 = unaryExpressionRest();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, unaryExpressionRest435.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 102, unaryExpressionAll_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "unaryExpressionAll"

    public static class unaryExpressionRest_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "unaryExpressionRest"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1037:1: unaryExpressionRest : ( NOT unaryExpressionAll -> ^( NOT unaryExpressionAll ) | LOGICAL_NOT unaryExpressionAll -> ^( LOGICAL_NOT unaryExpressionAll ) | LPAREN simpleType RPAREN unaryExpressionAll -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] simpleType unaryExpressionAll ) | LPAREN objectType RPAREN unaryExpressionRest -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] objectType unaryExpressionRest ) | postfixedExpression );

    public final JavaParser.unaryExpressionRest_return unaryExpressionRest() throws RecognitionException
    {
        JavaParser.unaryExpressionRest_return retval = new JavaParser.unaryExpressionRest_return();
        retval.start = input.LT(1);
        int unaryExpressionRest_StartIndex = input.index();
        CommonTree root_0 = null;

        Token NOT436 = null;
        Token LOGICAL_NOT438 = null;
        Token LPAREN440 = null;
        Token RPAREN442 = null;
        Token LPAREN444 = null;
        Token RPAREN446 = null;
        JavaParser.unaryExpressionAll_return unaryExpressionAll437 = null;

        JavaParser.unaryExpressionAll_return unaryExpressionAll439 = null;

        JavaParser.simpleType_return simpleType441 = null;

        JavaParser.unaryExpressionAll_return unaryExpressionAll443 = null;

        JavaParser.objectType_return objectType445 = null;

        JavaParser.unaryExpressionRest_return unaryExpressionRest447 = null;

        JavaParser.postfixedExpression_return postfixedExpression448 = null;


        CommonTree NOT436_tree = null;
        CommonTree LOGICAL_NOT438_tree = null;
        CommonTree LPAREN440_tree = null;
        CommonTree RPAREN442_tree = null;
        CommonTree LPAREN444_tree = null;
        CommonTree RPAREN446_tree = null;
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_LOGICAL_NOT = new RewriteRuleTokenStream(adaptor, "token LOGICAL_NOT");
        RewriteRuleTokenStream stream_NOT = new RewriteRuleTokenStream(adaptor, "token NOT");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleSubtreeStream stream_simpleType = new RewriteRuleSubtreeStream(adaptor, "rule simpleType");
        RewriteRuleSubtreeStream stream_unaryExpressionRest = new RewriteRuleSubtreeStream(adaptor, "rule unaryExpressionRest");
        RewriteRuleSubtreeStream stream_objectType = new RewriteRuleSubtreeStream(adaptor, "rule objectType");
        RewriteRuleSubtreeStream stream_unaryExpressionAll = new RewriteRuleSubtreeStream(adaptor, "rule unaryExpressionAll");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 103))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1038:5: ( NOT unaryExpressionAll -> ^( NOT unaryExpressionAll ) | LOGICAL_NOT unaryExpressionAll -> ^( LOGICAL_NOT unaryExpressionAll ) | LPAREN simpleType RPAREN unaryExpressionAll -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] simpleType unaryExpressionAll ) | LPAREN objectType RPAREN unaryExpressionRest -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] objectType unaryExpressionRest ) | postfixedExpression )
            int alt128 = 5;
            alt128 = dfa128.predict(input);
            switch (alt128)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1038:9: NOT unaryExpressionAll
                {
                    NOT436 = (Token) match(input, NOT, FOLLOW_NOT_in_unaryExpressionRest11393);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_NOT.add(NOT436);

                    pushFollow(FOLLOW_unaryExpressionAll_in_unaryExpressionRest11395);
                    unaryExpressionAll437 = unaryExpressionAll();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_unaryExpressionAll.add(unaryExpressionAll437.getTree());


                    // AST REWRITE
                    // elements: unaryExpressionAll, NOT
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1038:57: -> ^( NOT unaryExpressionAll )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1038:61: ^( NOT unaryExpressionAll )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_NOT.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_unaryExpressionAll.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1039:9: LOGICAL_NOT unaryExpressionAll
                {
                    LOGICAL_NOT438 = (Token) match(input, LOGICAL_NOT, FOLLOW_LOGICAL_NOT_in_unaryExpressionRest11439);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_LOGICAL_NOT.add(LOGICAL_NOT438);

                    pushFollow(FOLLOW_unaryExpressionAll_in_unaryExpressionRest11441);
                    unaryExpressionAll439 = unaryExpressionAll();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_unaryExpressionAll.add(unaryExpressionAll439.getTree());


                    // AST REWRITE
                    // elements: unaryExpressionAll, LOGICAL_NOT
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1039:57: -> ^( LOGICAL_NOT unaryExpressionAll )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1039:61: ^( LOGICAL_NOT unaryExpressionAll )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_LOGICAL_NOT.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_unaryExpressionAll.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1040:9: LPAREN simpleType RPAREN unaryExpressionAll
                {
                    LPAREN440 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_unaryExpressionRest11477);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_LPAREN.add(LPAREN440);

                    pushFollow(FOLLOW_simpleType_in_unaryExpressionRest11479);
                    simpleType441 = simpleType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_simpleType.add(simpleType441.getTree());
                    RPAREN442 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_unaryExpressionRest11481);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_RPAREN.add(RPAREN442);

                    pushFollow(FOLLOW_unaryExpressionAll_in_unaryExpressionRest11483);
                    unaryExpressionAll443 = unaryExpressionAll();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_unaryExpressionAll.add(unaryExpressionAll443.getTree());


                    // AST REWRITE
                    // elements: simpleType, unaryExpressionAll
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1040:57: -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] simpleType unaryExpressionAll )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1040:61: ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] simpleType unaryExpressionAll )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CAST_EXPR, LPAREN440, "CAST_EXPR"), root_1);

                                adaptor.addChild(root_1, stream_simpleType.nextTree());
                                adaptor.addChild(root_1, stream_unaryExpressionAll.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1041:9: LPAREN objectType RPAREN unaryExpressionRest
                {
                    LPAREN444 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_unaryExpressionRest11509);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_LPAREN.add(LPAREN444);

                    pushFollow(FOLLOW_objectType_in_unaryExpressionRest11511);
                    objectType445 = objectType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_objectType.add(objectType445.getTree());
                    RPAREN446 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_unaryExpressionRest11513);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_RPAREN.add(RPAREN446);

                    pushFollow(FOLLOW_unaryExpressionRest_in_unaryExpressionRest11515);
                    unaryExpressionRest447 = unaryExpressionRest();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_unaryExpressionRest.add(unaryExpressionRest447.getTree());


                    // AST REWRITE
                    // elements: objectType, unaryExpressionRest
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1041:57: -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] objectType unaryExpressionRest )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1041:61: ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] objectType unaryExpressionRest )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CAST_EXPR, LPAREN444, "CAST_EXPR"), root_1);

                                adaptor.addChild(root_1, stream_objectType.nextTree());
                                adaptor.addChild(root_1, stream_unaryExpressionRest.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1042:9: postfixedExpression
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_postfixedExpression_in_unaryExpressionRest11540);
                    postfixedExpression448 = postfixedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, postfixedExpression448.getTree());

                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 103, unaryExpressionRest_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "unaryExpressionRest"

    public static class postfixedExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "postfixedExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1045:1: postfixedExpression : ( primaryExpression -> primaryExpression ) (outerDot= DOT ( ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )? | THIS -> ^( DOT $postfixedExpression THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments ) | ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )? | innerNewExpression -> ^( DOT $postfixedExpression innerNewExpression ) ) | LBRACK expression RBRACK -> ^( ARRAY_ELEMENT_ACCESS $postfixedExpression expression ) )* ( INC -> ^( POST_INC[$INC, \"POST_INC\"] $postfixedExpression) | DEC -> ^( POST_DEC[$DEC, \"POST_DEC\"] $postfixedExpression) )? ;

    public final JavaParser.postfixedExpression_return postfixedExpression() throws RecognitionException
    {
        JavaParser.postfixedExpression_return retval = new JavaParser.postfixedExpression_return();
        retval.start = input.LT(1);
        int postfixedExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token outerDot = null;
        Token Super = null;
        Token innerDot = null;
        Token IDENT451 = null;
        Token THIS453 = null;
        Token SUPER455 = null;
        Token IDENT456 = null;
        Token LBRACK459 = null;
        Token RBRACK461 = null;
        Token INC462 = null;
        Token DEC463 = null;
        JavaParser.primaryExpression_return primaryExpression449 = null;

        JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified450 = null;

        JavaParser.arguments_return arguments452 = null;

        JavaParser.arguments_return arguments454 = null;

        JavaParser.arguments_return arguments457 = null;

        JavaParser.innerNewExpression_return innerNewExpression458 = null;

        JavaParser.expression_return expression460 = null;


        CommonTree outerDot_tree = null;
        CommonTree Super_tree = null;
        CommonTree innerDot_tree = null;
        CommonTree IDENT451_tree = null;
        CommonTree THIS453_tree = null;
        CommonTree SUPER455_tree = null;
        CommonTree IDENT456_tree = null;
        CommonTree LBRACK459_tree = null;
        CommonTree RBRACK461_tree = null;
        CommonTree INC462_tree = null;
        CommonTree DEC463_tree = null;
        RewriteRuleTokenStream stream_RBRACK = new RewriteRuleTokenStream(adaptor, "token RBRACK");
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_INC = new RewriteRuleTokenStream(adaptor, "token INC");
        RewriteRuleTokenStream stream_DEC = new RewriteRuleTokenStream(adaptor, "token DEC");
        RewriteRuleTokenStream stream_LBRACK = new RewriteRuleTokenStream(adaptor, "token LBRACK");
        RewriteRuleTokenStream stream_SUPER = new RewriteRuleTokenStream(adaptor, "token SUPER");
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor, "token DOT");
        RewriteRuleTokenStream stream_THIS = new RewriteRuleTokenStream(adaptor, "token THIS");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor, "rule expression");
        RewriteRuleSubtreeStream stream_arguments = new RewriteRuleSubtreeStream(adaptor, "rule arguments");
        RewriteRuleSubtreeStream stream_primaryExpression = new RewriteRuleSubtreeStream(adaptor, "rule primaryExpression");
        RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgumentListSimplified");
        RewriteRuleSubtreeStream stream_innerNewExpression = new RewriteRuleSubtreeStream(adaptor, "rule innerNewExpression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 104))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1047:5: ( ( primaryExpression -> primaryExpression ) (outerDot= DOT ( ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )? | THIS -> ^( DOT $postfixedExpression THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments ) | ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )? | innerNewExpression -> ^( DOT $postfixedExpression innerNewExpression ) ) | LBRACK expression RBRACK -> ^( ARRAY_ELEMENT_ACCESS $postfixedExpression expression ) )* ( INC -> ^( POST_INC[$INC, \"POST_INC\"] $postfixedExpression) | DEC -> ^( POST_DEC[$DEC, \"POST_DEC\"] $postfixedExpression) )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1047:9: ( primaryExpression -> primaryExpression ) (outerDot= DOT ( ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )? | THIS -> ^( DOT $postfixedExpression THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments ) | ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )? | innerNewExpression -> ^( DOT $postfixedExpression innerNewExpression ) ) | LBRACK expression RBRACK -> ^( ARRAY_ELEMENT_ACCESS $postfixedExpression expression ) )* ( INC -> ^( POST_INC[$INC, \"POST_INC\"] $postfixedExpression) | DEC -> ^( POST_DEC[$DEC, \"POST_DEC\"] $postfixedExpression) )?
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1047:9: ( primaryExpression -> primaryExpression )
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1047:13: primaryExpression
                {
                    pushFollow(FOLLOW_primaryExpression_in_postfixedExpression11572);
                    primaryExpression449 = primaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_primaryExpression.add(primaryExpression449.getTree());


                    // AST REWRITE
                    // elements: primaryExpression
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1047:53: -> primaryExpression
                        {
                            adaptor.addChild(root_0, stream_primaryExpression.nextTree());

                        }

                        retval.tree = root_0;
                    }
                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1050:9: (outerDot= DOT ( ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )? | THIS -> ^( DOT $postfixedExpression THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments ) | ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )? | innerNewExpression -> ^( DOT $postfixedExpression innerNewExpression ) ) | LBRACK expression RBRACK -> ^( ARRAY_ELEMENT_ACCESS $postfixedExpression expression ) )*
                loop133:
                do
                {
                    int alt133 = 3;
                    int LA133_0 = input.LA(1);

                    if ((LA133_0 == DOT))
                    {
                        alt133 = 1;
                    }
                    else if ((LA133_0 == LBRACK))
                    {
                        alt133 = 2;
                    }


                    switch (alt133)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1050:13: outerDot= DOT ( ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )? | THIS -> ^( DOT $postfixedExpression THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments ) | ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )? | innerNewExpression -> ^( DOT $postfixedExpression innerNewExpression ) )
                        {
                            outerDot = (Token) match(input, DOT, FOLLOW_DOT_in_postfixedExpression11634);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_DOT.add(outerDot);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1051:13: ( ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )? | THIS -> ^( DOT $postfixedExpression THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments ) | ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )? | innerNewExpression -> ^( DOT $postfixedExpression innerNewExpression ) )
                            int alt132 = 5;
                            switch (input.LA(1))
                            {
                                case LESS_THAN:
                                case IDENT:
                                {
                                    alt132 = 1;
                                }
                                break;
                                case THIS:
                                {
                                    alt132 = 2;
                                }
                                break;
                                case SUPER:
                                {
                                    int LA132_3 = input.LA(2);

                                    if ((LA132_3 == DOT))
                                    {
                                        alt132 = 4;
                                    }
                                    else if ((LA132_3 == LPAREN))
                                    {
                                        alt132 = 3;
                                    }
                                    else
                                    {
                                        if (state.backtracking > 0)
                                        {
                                            state.failed = true;
                                            return retval;
                                        }
                                        NoViableAltException nvae =
                                                new NoViableAltException("", 132, 3, input);

                                        throw nvae;
                                    }
                                }
                                break;
                                case NEW:
                                {
                                    alt132 = 5;
                                }
                                break;
                                default:
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    NoViableAltException nvae =
                                            new NoViableAltException("", 132, 0, input);

                                    throw nvae;
                            }

                            switch (alt132)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1051:17: ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )?
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1051:17: ( ( genericTypeArgumentListSimplified )? IDENT -> ^( DOT $postfixedExpression IDENT ) )
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1051:21: ( genericTypeArgumentListSimplified )? IDENT
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1051:21: ( genericTypeArgumentListSimplified )?
                                        int alt129 = 2;
                                        int LA129_0 = input.LA(1);

                                        if ((LA129_0 == LESS_THAN))
                                        {
                                            alt129 = 1;
                                        }
                                        switch (alt129)
                                        {
                                            case 1:
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeArgumentListSimplified
                                            {
                                                pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_postfixedExpression11656);
                                                genericTypeArgumentListSimplified450 = genericTypeArgumentListSimplified();

                                                state._fsp--;
                                                if (state.failed) return retval;
                                                if (state.backtracking == 0)
                                                    stream_genericTypeArgumentListSimplified.add(genericTypeArgumentListSimplified450.getTree());

                                            }
                                            break;

                                        }

                                        IDENT451 = (Token) match(input, IDENT, FOLLOW_IDENT_in_postfixedExpression11738);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_IDENT.add(IDENT451);


                                        // AST REWRITE
                                        // elements: postfixedExpression, DOT, IDENT
                                        // token labels:
                                        // rule labels: retval
                                        // token list labels:
                                        // rule list labels:
                                        // wildcard labels:
                                        if (state.backtracking == 0)
                                        {
                                            retval.tree = root_0;
                                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                            root_0 = (CommonTree) adaptor.nil();
                                            // 1053:53: -> ^( DOT $postfixedExpression IDENT )
                                            {
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1053:57: ^( DOT $postfixedExpression IDENT )
                                                {
                                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                                    root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                                    adaptor.addChild(root_1, stream_retval.nextTree());
                                                    adaptor.addChild(root_1, stream_IDENT.nextNode());

                                                    adaptor.addChild(root_0, root_1);
                                                }

                                            }

                                            retval.tree = root_0;
                                        }
                                    }

                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1055:17: ( arguments -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments ) )?
                                    int alt130 = 2;
                                    int LA130_0 = input.LA(1);

                                    if ((LA130_0 == LPAREN))
                                    {
                                        alt130 = 1;
                                    }
                                    switch (alt130)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1055:21: arguments
                                        {
                                            pushFollow(FOLLOW_arguments_in_postfixedExpression11816);
                                            arguments452 = arguments();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0) stream_arguments.add(arguments452.getTree());


                                            // AST REWRITE
                                            // elements: postfixedExpression, genericTypeArgumentListSimplified, arguments
                                            // token labels:
                                            // rule labels: retval
                                            // token list labels:
                                            // rule list labels:
                                            // wildcard labels:
                                            if (state.backtracking == 0)
                                            {
                                                retval.tree = root_0;
                                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                                root_0 = (CommonTree) adaptor.nil();
                                                // 1055:53: -> ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments )
                                                {
                                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1055:57: ^( METHOD_CALL $postfixedExpression ( genericTypeArgumentListSimplified )? arguments )
                                                    {
                                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                                        adaptor.addChild(root_1, stream_retval.nextTree());
                                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1055:92: ( genericTypeArgumentListSimplified )?
                                                        if (stream_genericTypeArgumentListSimplified.hasNext())
                                                        {
                                                            adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());

                                                        }
                                                        stream_genericTypeArgumentListSimplified.reset();
                                                        adaptor.addChild(root_1, stream_arguments.nextTree());

                                                        adaptor.addChild(root_0, root_1);
                                                    }

                                                }

                                                retval.tree = root_0;
                                            }
                                        }
                                        break;

                                    }


                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1057:17: THIS
                                {
                                    THIS453 = (Token) match(input, THIS, FOLLOW_THIS_in_postfixedExpression11890);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_THIS.add(THIS453);


                                    // AST REWRITE
                                    // elements: postfixedExpression, DOT, THIS
                                    // token labels:
                                    // rule labels: retval
                                    // token list labels:
                                    // rule list labels:
                                    // wildcard labels:
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 1057:53: -> ^( DOT $postfixedExpression THIS )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1057:57: ^( DOT $postfixedExpression THIS )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                                adaptor.addChild(root_1, stream_retval.nextTree());
                                                adaptor.addChild(root_1, stream_THIS.nextNode());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;
                                case 3:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1058:17: Super= SUPER arguments
                                {
                                    Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_postfixedExpression11953);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_SUPER.add(Super);

                                    pushFollow(FOLLOW_arguments_in_postfixedExpression11955);
                                    arguments454 = arguments();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_arguments.add(arguments454.getTree());


                                    // AST REWRITE
                                    // elements: arguments, postfixedExpression
                                    // token labels:
                                    // rule labels: retval
                                    // token list labels:
                                    // rule list labels:
                                    // wildcard labels:
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 1058:57: -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1058:61: ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] $postfixedExpression arguments )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(SUPER_CONSTRUCTOR_CALL, Super, "SUPER_CONSTRUCTOR_CALL"), root_1);

                                                adaptor.addChild(root_1, stream_retval.nextTree());
                                                adaptor.addChild(root_1, stream_arguments.nextTree());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;
                                case 4:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1059:17: ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) ) ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )?
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1059:17: ( SUPER innerDot= DOT IDENT -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT ) )
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1059:21: SUPER innerDot= DOT IDENT
                                    {
                                        SUPER455 = (Token) match(input, SUPER, FOLLOW_SUPER_in_postfixedExpression12008);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_SUPER.add(SUPER455);

                                        innerDot = (Token) match(input, DOT, FOLLOW_DOT_in_postfixedExpression12012);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_DOT.add(innerDot);

                                        IDENT456 = (Token) match(input, IDENT, FOLLOW_IDENT_in_postfixedExpression12014);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_IDENT.add(IDENT456);


                                        // AST REWRITE
                                        // elements: innerDot, IDENT, postfixedExpression, outerDot, SUPER
                                        // token labels: outerDot, innerDot
                                        // rule labels: retval
                                        // token list labels:
                                        // rule list labels:
                                        // wildcard labels:
                                        if (state.backtracking == 0)
                                        {
                                            retval.tree = root_0;
                                            RewriteRuleTokenStream stream_outerDot = new RewriteRuleTokenStream(adaptor, "token outerDot", outerDot);
                                            RewriteRuleTokenStream stream_innerDot = new RewriteRuleTokenStream(adaptor, "token innerDot", innerDot);
                                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                            root_0 = (CommonTree) adaptor.nil();
                                            // 1059:53: -> ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT )
                                            {
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1059:57: ^( $innerDot ^( $outerDot $postfixedExpression SUPER ) IDENT )
                                                {
                                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                                    root_1 = (CommonTree) adaptor.becomeRoot(stream_innerDot.nextNode(), root_1);

                                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1059:69: ^( $outerDot $postfixedExpression SUPER )
                                                    {
                                                        CommonTree root_2 = (CommonTree) adaptor.nil();
                                                        root_2 = (CommonTree) adaptor.becomeRoot(stream_outerDot.nextNode(), root_2);

                                                        adaptor.addChild(root_2, stream_retval.nextTree());
                                                        adaptor.addChild(root_2, stream_SUPER.nextNode());

                                                        adaptor.addChild(root_1, root_2);
                                                    }
                                                    adaptor.addChild(root_1, stream_IDENT.nextNode());

                                                    adaptor.addChild(root_0, root_1);
                                                }

                                            }

                                            retval.tree = root_0;
                                        }
                                    }

                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1061:17: ( arguments -> ^( METHOD_CALL $postfixedExpression arguments ) )?
                                    int alt131 = 2;
                                    int LA131_0 = input.LA(1);

                                    if ((LA131_0 == LPAREN))
                                    {
                                        alt131 = 1;
                                    }
                                    switch (alt131)
                                    {
                                        case 1:
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1061:21: arguments
                                        {
                                            pushFollow(FOLLOW_arguments_in_postfixedExpression12081);
                                            arguments457 = arguments();

                                            state._fsp--;
                                            if (state.failed) return retval;
                                            if (state.backtracking == 0) stream_arguments.add(arguments457.getTree());


                                            // AST REWRITE
                                            // elements: postfixedExpression, arguments
                                            // token labels:
                                            // rule labels: retval
                                            // token list labels:
                                            // rule list labels:
                                            // wildcard labels:
                                            if (state.backtracking == 0)
                                            {
                                                retval.tree = root_0;
                                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                                root_0 = (CommonTree) adaptor.nil();
                                                // 1061:53: -> ^( METHOD_CALL $postfixedExpression arguments )
                                                {
                                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1061:57: ^( METHOD_CALL $postfixedExpression arguments )
                                                    {
                                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                                        adaptor.addChild(root_1, stream_retval.nextTree());
                                                        adaptor.addChild(root_1, stream_arguments.nextTree());

                                                        adaptor.addChild(root_0, root_1);
                                                    }

                                                }

                                                retval.tree = root_0;
                                            }
                                        }
                                        break;

                                    }


                                }
                                break;
                                case 5:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1063:17: innerNewExpression
                                {
                                    pushFollow(FOLLOW_innerNewExpression_in_postfixedExpression12152);
                                    innerNewExpression458 = innerNewExpression();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_innerNewExpression.add(innerNewExpression458.getTree());


                                    // AST REWRITE
                                    // elements: DOT, innerNewExpression, postfixedExpression
                                    // token labels:
                                    // rule labels: retval
                                    // token list labels:
                                    // rule list labels:
                                    // wildcard labels:
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 1063:53: -> ^( DOT $postfixedExpression innerNewExpression )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1063:57: ^( DOT $postfixedExpression innerNewExpression )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                                adaptor.addChild(root_1, stream_retval.nextTree());
                                                adaptor.addChild(root_1, stream_innerNewExpression.nextTree());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;

                            }


                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1065:13: LBRACK expression RBRACK
                        {
                            LBRACK459 = (Token) match(input, LBRACK, FOLLOW_LBRACK_in_postfixedExpression12209);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_LBRACK.add(LBRACK459);

                            pushFollow(FOLLOW_expression_in_postfixedExpression12211);
                            expression460 = expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_expression.add(expression460.getTree());
                            RBRACK461 = (Token) match(input, RBRACK, FOLLOW_RBRACK_in_postfixedExpression12213);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_RBRACK.add(RBRACK461);


                            // AST REWRITE
                            // elements: postfixedExpression, expression
                            // token labels:
                            // rule labels: retval
                            // token list labels:
                            // rule list labels:
                            // wildcard labels:
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1065:53: -> ^( ARRAY_ELEMENT_ACCESS $postfixedExpression expression )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1065:57: ^( ARRAY_ELEMENT_ACCESS $postfixedExpression expression )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ARRAY_ELEMENT_ACCESS, "ARRAY_ELEMENT_ACCESS"), root_1);

                                        adaptor.addChild(root_1, stream_retval.nextTree());
                                        adaptor.addChild(root_1, stream_expression.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                        default:
                            break loop133;
                    }
                }
                while (true);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1068:9: ( INC -> ^( POST_INC[$INC, \"POST_INC\"] $postfixedExpression) | DEC -> ^( POST_DEC[$DEC, \"POST_DEC\"] $postfixedExpression) )?
                int alt134 = 3;
                int LA134_0 = input.LA(1);

                if ((LA134_0 == INC))
                {
                    alt134 = 1;
                }
                else if ((LA134_0 == DEC))
                {
                    alt134 = 2;
                }
                switch (alt134)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1068:13: INC
                    {
                        INC462 = (Token) match(input, INC, FOLLOW_INC_in_postfixedExpression12274);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_INC.add(INC462);


                        // AST REWRITE
                        // elements: postfixedExpression
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 1068:17: -> ^( POST_INC[$INC, \"POST_INC\"] $postfixedExpression)
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1068:20: ^( POST_INC[$INC, \"POST_INC\"] $postfixedExpression)
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(POST_INC, INC462, "POST_INC"), root_1);

                                    adaptor.addChild(root_1, stream_retval.nextTree());

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;
                    case 2:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1069:13: DEC
                    {
                        DEC463 = (Token) match(input, DEC, FOLLOW_DEC_in_postfixedExpression12298);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_DEC.add(DEC463);


                        // AST REWRITE
                        // elements: postfixedExpression
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 1069:17: -> ^( POST_DEC[$DEC, \"POST_DEC\"] $postfixedExpression)
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1069:20: ^( POST_DEC[$DEC, \"POST_DEC\"] $postfixedExpression)
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(POST_DEC, DEC463, "POST_DEC"), root_1);

                                    adaptor.addChild(root_1, stream_retval.nextTree());

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 104, postfixedExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "postfixedExpression"

    public static class primaryExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "primaryExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1073:1: primaryExpression : ( parenthesizedExpression | literal | newExpression | qualifiedIdentExpression | genericTypeArgumentListSimplified ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) ) | ( THIS -> THIS ) ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )? | SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments ) | ( SUPER DOT IDENT ) ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) ) | ( primitiveType -> primitiveType ) ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )* DOT CLASS -> ^( DOT $primaryExpression CLASS ) | VOID DOT CLASS -> ^( DOT VOID CLASS ) );

    public final JavaParser.primaryExpression_return primaryExpression() throws RecognitionException
    {
        JavaParser.primaryExpression_return retval = new JavaParser.primaryExpression_return();
        retval.start = input.LT(1);
        int primaryExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token SUPER469 = null;
        Token DOT471 = null;
        Token IDENT472 = null;
        Token IDENT474 = null;
        Token THIS476 = null;
        Token THIS478 = null;
        Token SUPER480 = null;
        Token SUPER482 = null;
        Token DOT483 = null;
        Token IDENT484 = null;
        Token DOT488 = null;
        Token CLASS489 = null;
        Token VOID490 = null;
        Token DOT491 = null;
        Token CLASS492 = null;
        JavaParser.parenthesizedExpression_return parenthesizedExpression464 = null;

        JavaParser.literal_return literal465 = null;

        JavaParser.newExpression_return newExpression466 = null;

        JavaParser.qualifiedIdentExpression_return qualifiedIdentExpression467 = null;

        JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified468 = null;

        JavaParser.arguments_return arguments470 = null;

        JavaParser.arguments_return arguments473 = null;

        JavaParser.arguments_return arguments475 = null;

        JavaParser.arguments_return arguments477 = null;

        JavaParser.arguments_return arguments479 = null;

        JavaParser.arguments_return arguments481 = null;

        JavaParser.arguments_return arguments485 = null;

        JavaParser.primitiveType_return primitiveType486 = null;

        JavaParser.arrayDeclarator_return arrayDeclarator487 = null;


        CommonTree SUPER469_tree = null;
        CommonTree DOT471_tree = null;
        CommonTree IDENT472_tree = null;
        CommonTree IDENT474_tree = null;
        CommonTree THIS476_tree = null;
        CommonTree THIS478_tree = null;
        CommonTree SUPER480_tree = null;
        CommonTree SUPER482_tree = null;
        CommonTree DOT483_tree = null;
        CommonTree IDENT484_tree = null;
        CommonTree DOT488_tree = null;
        CommonTree CLASS489_tree = null;
        CommonTree VOID490_tree = null;
        CommonTree DOT491_tree = null;
        CommonTree CLASS492_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_CLASS = new RewriteRuleTokenStream(adaptor, "token CLASS");
        RewriteRuleTokenStream stream_VOID = new RewriteRuleTokenStream(adaptor, "token VOID");
        RewriteRuleTokenStream stream_SUPER = new RewriteRuleTokenStream(adaptor, "token SUPER");
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor, "token DOT");
        RewriteRuleTokenStream stream_THIS = new RewriteRuleTokenStream(adaptor, "token THIS");
        RewriteRuleSubtreeStream stream_arrayDeclarator = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclarator");
        RewriteRuleSubtreeStream stream_arguments = new RewriteRuleSubtreeStream(adaptor, "rule arguments");
        RewriteRuleSubtreeStream stream_primitiveType = new RewriteRuleSubtreeStream(adaptor, "rule primitiveType");
        RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgumentListSimplified");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 105))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1074:5: ( parenthesizedExpression | literal | newExpression | qualifiedIdentExpression | genericTypeArgumentListSimplified ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) ) | ( THIS -> THIS ) ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )? | SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments ) | ( SUPER DOT IDENT ) ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) ) | ( primitiveType -> primitiveType ) ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )* DOT CLASS -> ^( DOT $primaryExpression CLASS ) | VOID DOT CLASS -> ^( DOT VOID CLASS ) )
            int alt140 = 10;
            alt140 = dfa140.predict(input);
            switch (alt140)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1074:9: parenthesizedExpression
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_parenthesizedExpression_in_primaryExpression12338);
                    parenthesizedExpression464 = parenthesizedExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, parenthesizedExpression464.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1075:9: literal
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_literal_in_primaryExpression12348);
                    literal465 = literal();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, literal465.getTree());

                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1076:9: newExpression
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_newExpression_in_primaryExpression12358);
                    newExpression466 = newExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, newExpression466.getTree());

                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1077:9: qualifiedIdentExpression
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_qualifiedIdentExpression_in_primaryExpression12368);
                    qualifiedIdentExpression467 = qualifiedIdentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, qualifiedIdentExpression467.getTree());

                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1078:9: genericTypeArgumentListSimplified ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) )
                {
                    pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_primaryExpression12378);
                    genericTypeArgumentListSimplified468 = genericTypeArgumentListSimplified();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0)
                        stream_genericTypeArgumentListSimplified.add(genericTypeArgumentListSimplified468.getTree());
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1079:9: ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) )
                    int alt136 = 3;
                    switch (input.LA(1))
                    {
                        case SUPER:
                        {
                            alt136 = 1;
                        }
                        break;
                        case IDENT:
                        {
                            alt136 = 2;
                        }
                        break;
                        case THIS:
                        {
                            alt136 = 3;
                        }
                        break;
                        default:
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 136, 0, input);

                            throw nvae;
                    }

                    switch (alt136)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1079:13: SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) )
                        {
                            SUPER469 = (Token) match(input, SUPER, FOLLOW_SUPER_in_primaryExpression12392);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_SUPER.add(SUPER469);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1080:13: ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) )
                            int alt135 = 2;
                            int LA135_0 = input.LA(1);

                            if ((LA135_0 == LPAREN))
                            {
                                alt135 = 1;
                            }
                            else if ((LA135_0 == DOT))
                            {
                                alt135 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 135, 0, input);

                                throw nvae;
                            }
                            switch (alt135)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1080:17: arguments
                                {
                                    pushFollow(FOLLOW_arguments_in_primaryExpression12410);
                                    arguments470 = arguments();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_arguments.add(arguments470.getTree());


                                    // AST REWRITE
                                    // elements: genericTypeArgumentListSimplified, arguments
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 1080:57: -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1080:61: ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(SUPER_CONSTRUCTOR_CALL, SUPER469, "SUPER_CONSTRUCTOR_CALL"), root_1);

                                                adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                                adaptor.addChild(root_1, stream_arguments.nextTree());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1081:17: DOT IDENT arguments
                                {
                                    DOT471 = (Token) match(input, DOT, FOLLOW_DOT_in_primaryExpression12470);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_DOT.add(DOT471);

                                    IDENT472 = (Token) match(input, IDENT, FOLLOW_IDENT_in_primaryExpression12472);
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_IDENT.add(IDENT472);

                                    pushFollow(FOLLOW_arguments_in_primaryExpression12474);
                                    arguments473 = arguments();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0) stream_arguments.add(arguments473.getTree());


                                    // AST REWRITE
                                    // elements: IDENT, arguments, SUPER, genericTypeArgumentListSimplified, DOT
                                    // token labels: 
                                    // rule labels: retval
                                    // token list labels: 
                                    // rule list labels: 
                                    // wildcard labels: 
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 1081:57: -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments )
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1081:61: ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments )
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1081:75: ^( DOT SUPER IDENT )
                                                {
                                                    CommonTree root_2 = (CommonTree) adaptor.nil();
                                                    root_2 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_2);

                                                    adaptor.addChild(root_2, stream_SUPER.nextNode());
                                                    adaptor.addChild(root_2, stream_IDENT.nextNode());

                                                    adaptor.addChild(root_1, root_2);
                                                }
                                                adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                                adaptor.addChild(root_1, stream_arguments.nextTree());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;

                            }


                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1083:13: IDENT arguments
                        {
                            IDENT474 = (Token) match(input, IDENT, FOLLOW_IDENT_in_primaryExpression12541);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_IDENT.add(IDENT474);

                            pushFollow(FOLLOW_arguments_in_primaryExpression12543);
                            arguments475 = arguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_arguments.add(arguments475.getTree());


                            // AST REWRITE
                            // elements: arguments, IDENT, genericTypeArgumentListSimplified
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1083:57: -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1083:61: ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                        adaptor.addChild(root_1, stream_IDENT.nextNode());
                                        adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                        adaptor.addChild(root_1, stream_arguments.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;
                        case 3:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1084:13: THIS arguments
                        {
                            THIS476 = (Token) match(input, THIS, FOLLOW_THIS_in_primaryExpression12598);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_THIS.add(THIS476);

                            pushFollow(FOLLOW_arguments_in_primaryExpression12600);
                            arguments477 = arguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_arguments.add(arguments477.getTree());


                            // AST REWRITE
                            // elements: genericTypeArgumentListSimplified, arguments
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1084:57: -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1084:61: ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(THIS_CONSTRUCTOR_CALL, THIS476, "THIS_CONSTRUCTOR_CALL"), root_1);

                                        adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                        adaptor.addChild(root_1, stream_arguments.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 6:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1086:9: ( THIS -> THIS ) ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )?
                {
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1086:9: ( THIS -> THIS )
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1086:13: THIS
                    {
                        THIS478 = (Token) match(input, THIS, FOLLOW_THIS_in_primaryExpression12665);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_THIS.add(THIS478);


                        // AST REWRITE
                        // elements: THIS
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 1086:57: -> THIS
                            {
                                adaptor.addChild(root_0, stream_THIS.nextNode());

                            }

                            retval.tree = root_0;
                        }
                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1088:9: ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )?
                    int alt137 = 2;
                    int LA137_0 = input.LA(1);

                    if ((LA137_0 == LPAREN))
                    {
                        alt137 = 1;
                    }
                    switch (alt137)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1088:13: arguments
                        {
                            pushFollow(FOLLOW_arguments_in_primaryExpression12733);
                            arguments479 = arguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_arguments.add(arguments479.getTree());


                            // AST REWRITE
                            // elements: arguments
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1088:57: -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1088:61: ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(THIS_CONSTRUCTOR_CALL, THIS478, "THIS_CONSTRUCTOR_CALL"), root_1);

                                        adaptor.addChild(root_1, stream_arguments.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 7:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1090:9: SUPER arguments
                {
                    SUPER480 = (Token) match(input, SUPER, FOLLOW_SUPER_in_primaryExpression12798);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_SUPER.add(SUPER480);

                    pushFollow(FOLLOW_arguments_in_primaryExpression12800);
                    arguments481 = arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_arguments.add(arguments481.getTree());


                    // AST REWRITE
                    // elements: arguments
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1090:57: -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1090:61: ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(SUPER_CONSTRUCTOR_CALL, SUPER480, "SUPER_CONSTRUCTOR_CALL"), root_1);

                                adaptor.addChild(root_1, stream_arguments.nextTree());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 8:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1091:9: ( SUPER DOT IDENT ) ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) )
                {
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1091:9: ( SUPER DOT IDENT )
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1091:13: SUPER DOT IDENT
                    {
                        SUPER482 = (Token) match(input, SUPER, FOLLOW_SUPER_in_primaryExpression12856);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_SUPER.add(SUPER482);

                        DOT483 = (Token) match(input, DOT, FOLLOW_DOT_in_primaryExpression12858);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_DOT.add(DOT483);

                        IDENT484 = (Token) match(input, IDENT, FOLLOW_IDENT_in_primaryExpression12860);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_IDENT.add(IDENT484);


                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1093:9: ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) )
                    int alt138 = 2;
                    int LA138_0 = input.LA(1);

                    if ((LA138_0 == LPAREN))
                    {
                        alt138 = 1;
                    }
                    else if ((LA138_0 == EOF || (LA138_0 >= AND && LA138_0 <= ASSIGN) || (LA138_0 >= BIT_SHIFT_RIGHT && LA138_0 <= DOT) || (LA138_0 >= EQUAL && LA138_0 <= LBRACK) || (LA138_0 >= LESS_OR_EQUAL && LA138_0 <= LOGICAL_AND) || LA138_0 == LOGICAL_OR || (LA138_0 >= MINUS && LA138_0 <= MOD_ASSIGN) || (LA138_0 >= NOT_EQUAL && LA138_0 <= XOR_ASSIGN) || LA138_0 == INSTANCEOF))
                    {
                        alt138 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 138, 0, input);

                        throw nvae;
                    }
                    switch (alt138)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1093:13: arguments
                        {
                            pushFollow(FOLLOW_arguments_in_primaryExpression12884);
                            arguments485 = arguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_arguments.add(arguments485.getTree());


                            // AST REWRITE
                            // elements: arguments, SUPER, IDENT, DOT
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1093:57: -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1093:61: ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1093:75: ^( DOT SUPER IDENT )
                                        {
                                            CommonTree root_2 = (CommonTree) adaptor.nil();
                                            root_2 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_2);

                                            adaptor.addChild(root_2, stream_SUPER.nextNode());
                                            adaptor.addChild(root_2, stream_IDENT.nextNode());

                                            adaptor.addChild(root_1, root_2);
                                        }
                                        adaptor.addChild(root_1, stream_arguments.nextTree());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1094:57: 
                        {

                            // AST REWRITE
                            // elements: SUPER, DOT, IDENT
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1094:57: -> ^( DOT SUPER IDENT )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1094:61: ^( DOT SUPER IDENT )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_SUPER.nextNode());
                                        adaptor.addChild(root_1, stream_IDENT.nextNode());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }
                        break;

                    }


                }
                break;
                case 9:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1096:9: ( primitiveType -> primitiveType ) ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )* DOT CLASS
                {
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1096:9: ( primitiveType -> primitiveType )
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1096:13: primitiveType
                    {
                        pushFollow(FOLLOW_primitiveType_in_primaryExpression13026);
                        primitiveType486 = primitiveType();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_primitiveType.add(primitiveType486.getTree());


                        // AST REWRITE
                        // elements: primitiveType
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 1096:57: -> primitiveType
                            {
                                adaptor.addChild(root_0, stream_primitiveType.nextTree());

                            }

                            retval.tree = root_0;
                        }
                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1098:9: ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )*
                    loop139:
                    do
                    {
                        int alt139 = 2;
                        int LA139_0 = input.LA(1);

                        if ((LA139_0 == LBRACK))
                        {
                            alt139 = 1;
                        }


                        switch (alt139)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1098:13: arrayDeclarator
                            {
                                pushFollow(FOLLOW_arrayDeclarator_in_primaryExpression13085);
                                arrayDeclarator487 = arrayDeclarator();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_arrayDeclarator.add(arrayDeclarator487.getTree());


                                // AST REWRITE
                                // elements: arrayDeclarator, primaryExpression
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1098:57: -> ^( arrayDeclarator $primaryExpression)
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1098:61: ^( arrayDeclarator $primaryExpression)
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot(stream_arrayDeclarator.nextNode(), root_1);

                                            adaptor.addChild(root_1, stream_retval.nextTree());

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;

                            default:
                                break loop139;
                        }
                    }
                    while (true);

                    DOT488 = (Token) match(input, DOT, FOLLOW_DOT_in_primaryExpression13144);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_DOT.add(DOT488);

                    CLASS489 = (Token) match(input, CLASS, FOLLOW_CLASS_in_primaryExpression13146);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_CLASS.add(CLASS489);


                    // AST REWRITE
                    // elements: DOT, CLASS, primaryExpression
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1100:57: -> ^( DOT $primaryExpression CLASS )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1100:61: ^( DOT $primaryExpression CLASS )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_retval.nextTree());
                                adaptor.addChild(root_1, stream_CLASS.nextNode());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;
                case 10:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1101:9: VOID DOT CLASS
                {
                    VOID490 = (Token) match(input, VOID, FOLLOW_VOID_in_primaryExpression13206);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_VOID.add(VOID490);

                    DOT491 = (Token) match(input, DOT, FOLLOW_DOT_in_primaryExpression13208);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_DOT.add(DOT491);

                    CLASS492 = (Token) match(input, CLASS, FOLLOW_CLASS_in_primaryExpression13210);
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_CLASS.add(CLASS492);


                    // AST REWRITE
                    // elements: VOID, DOT, CLASS
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1101:57: -> ^( DOT VOID CLASS )
                        {
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1101:61: ^( DOT VOID CLASS )
                            {
                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                adaptor.addChild(root_1, stream_VOID.nextNode());
                                adaptor.addChild(root_1, stream_CLASS.nextNode());

                                adaptor.addChild(root_0, root_1);
                            }

                        }

                        retval.tree = root_0;
                    }
                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 105, primaryExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "primaryExpression"

    public static class qualifiedIdentExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "qualifiedIdentExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1104:1: qualifiedIdentExpression : ( qualifiedIdentifier -> qualifiedIdentifier ) ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) | outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )? ;

    public final JavaParser.qualifiedIdentExpression_return qualifiedIdentExpression() throws RecognitionException
    {
        JavaParser.qualifiedIdentExpression_return retval = new JavaParser.qualifiedIdentExpression_return();
        retval.start = input.LT(1);
        int qualifiedIdentExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token outerDot = null;
        Token Super = null;
        Token innerDot = null;
        Token DOT495 = null;
        Token CLASS496 = null;
        Token CLASS498 = null;
        Token SUPER501 = null;
        Token IDENT502 = null;
        Token IDENT504 = null;
        Token THIS506 = null;
        JavaParser.qualifiedIdentifier_return qualifiedIdentifier493 = null;

        JavaParser.arrayDeclarator_return arrayDeclarator494 = null;

        JavaParser.arguments_return arguments497 = null;

        JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified499 = null;

        JavaParser.arguments_return arguments500 = null;

        JavaParser.arguments_return arguments503 = null;

        JavaParser.arguments_return arguments505 = null;

        JavaParser.arguments_return arguments507 = null;

        JavaParser.innerNewExpression_return innerNewExpression508 = null;


        CommonTree outerDot_tree = null;
        CommonTree Super_tree = null;
        CommonTree innerDot_tree = null;
        CommonTree DOT495_tree = null;
        CommonTree CLASS496_tree = null;
        CommonTree CLASS498_tree = null;
        CommonTree SUPER501_tree = null;
        CommonTree IDENT502_tree = null;
        CommonTree IDENT504_tree = null;
        CommonTree THIS506_tree = null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleTokenStream stream_CLASS = new RewriteRuleTokenStream(adaptor, "token CLASS");
        RewriteRuleTokenStream stream_SUPER = new RewriteRuleTokenStream(adaptor, "token SUPER");
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor, "token DOT");
        RewriteRuleTokenStream stream_THIS = new RewriteRuleTokenStream(adaptor, "token THIS");
        RewriteRuleSubtreeStream stream_arrayDeclarator = new RewriteRuleSubtreeStream(adaptor, "rule arrayDeclarator");
        RewriteRuleSubtreeStream stream_arguments = new RewriteRuleSubtreeStream(adaptor, "rule arguments");
        RewriteRuleSubtreeStream stream_qualifiedIdentifier = new RewriteRuleSubtreeStream(adaptor, "rule qualifiedIdentifier");
        RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgumentListSimplified");
        RewriteRuleSubtreeStream stream_innerNewExpression = new RewriteRuleSubtreeStream(adaptor, "rule innerNewExpression");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 106))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1106:5: ( ( qualifiedIdentifier -> qualifiedIdentifier ) ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) | outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )? )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1106:9: ( qualifiedIdentifier -> qualifiedIdentifier ) ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) | outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )?
            {
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1106:9: ( qualifiedIdentifier -> qualifiedIdentifier )
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1106:13: qualifiedIdentifier
                {
                    pushFollow(FOLLOW_qualifiedIdentifier_in_qualifiedIdentExpression13286);
                    qualifiedIdentifier493 = qualifiedIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) stream_qualifiedIdentifier.add(qualifiedIdentifier493.getTree());


                    // AST REWRITE
                    // elements: qualifiedIdentifier
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    if (state.backtracking == 0)
                    {
                        retval.tree = root_0;
                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                        root_0 = (CommonTree) adaptor.nil();
                        // 1106:61: -> qualifiedIdentifier
                        {
                            adaptor.addChild(root_0, stream_qualifiedIdentifier.nextTree());

                        }

                        retval.tree = root_0;
                    }
                }

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:9: ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) | outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )?
                int alt144 = 4;
                alt144 = dfa144.predict(input);
                switch (alt144)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:13: ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:13: ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+
                        int cnt141 = 0;
                        loop141:
                        do
                        {
                            int alt141 = 2;
                            int LA141_0 = input.LA(1);

                            if ((LA141_0 == LBRACK))
                            {
                                alt141 = 1;
                            }


                            switch (alt141)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:17: arrayDeclarator
                                {
                                    pushFollow(FOLLOW_arrayDeclarator_in_qualifiedIdentExpression13356);
                                    arrayDeclarator494 = arrayDeclarator();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    if (state.backtracking == 0)
                                        stream_arrayDeclarator.add(arrayDeclarator494.getTree());


                                    // AST REWRITE
                                    // elements: arrayDeclarator, qualifiedIdentExpression
                                    // token labels:
                                    // rule labels: retval
                                    // token list labels:
                                    // rule list labels:
                                    // wildcard labels:
                                    if (state.backtracking == 0)
                                    {
                                        retval.tree = root_0;
                                        RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                        root_0 = (CommonTree) adaptor.nil();
                                        // 1109:57: -> ^( arrayDeclarator $qualifiedIdentExpression)
                                        {
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:61: ^( arrayDeclarator $qualifiedIdentExpression)
                                            {
                                                CommonTree root_1 = (CommonTree) adaptor.nil();
                                                root_1 = (CommonTree) adaptor.becomeRoot(stream_arrayDeclarator.nextNode(), root_1);

                                                adaptor.addChild(root_1, stream_retval.nextTree());

                                                adaptor.addChild(root_0, root_1);
                                            }

                                        }

                                        retval.tree = root_0;
                                    }
                                }
                                break;

                                default:
                                    if (cnt141 >= 1) break loop141;
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    EarlyExitException eee =
                                            new EarlyExitException(141, input);
                                    throw eee;
                            }
                            cnt141++;
                        }
                        while (true);

                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1111:13: ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) )
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1111:17: DOT CLASS
                        {
                            DOT495 = (Token) match(input, DOT, FOLLOW_DOT_in_qualifiedIdentExpression13423);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_DOT.add(DOT495);

                            CLASS496 = (Token) match(input, CLASS, FOLLOW_CLASS_in_qualifiedIdentExpression13425);
                            if (state.failed) return retval;
                            if (state.backtracking == 0) stream_CLASS.add(CLASS496);


                            // AST REWRITE
                            // elements: qualifiedIdentExpression, DOT, CLASS
                            // token labels:
                            // rule labels: retval
                            // token list labels:
                            // rule list labels:
                            // wildcard labels:
                            if (state.backtracking == 0)
                            {
                                retval.tree = root_0;
                                RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                root_0 = (CommonTree) adaptor.nil();
                                // 1111:57: -> ^( DOT $qualifiedIdentExpression CLASS )
                                {
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1111:61: ^( DOT $qualifiedIdentExpression CLASS )
                                    {
                                        CommonTree root_1 = (CommonTree) adaptor.nil();
                                        root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                        adaptor.addChild(root_1, stream_retval.nextTree());
                                        adaptor.addChild(root_1, stream_CLASS.nextNode());

                                        adaptor.addChild(root_0, root_1);
                                    }

                                }

                                retval.tree = root_0;
                            }
                        }


                    }
                    break;
                    case 2:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1113:13: arguments
                    {
                        pushFollow(FOLLOW_arguments_in_qualifiedIdentExpression13495);
                        arguments497 = arguments();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_arguments.add(arguments497.getTree());


                        // AST REWRITE
                        // elements: arguments, qualifiedIdentifier
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 1113:57: -> ^( METHOD_CALL qualifiedIdentifier arguments )
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1113:61: ^( METHOD_CALL qualifiedIdentifier arguments )
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                    adaptor.addChild(root_1, stream_qualifiedIdentifier.nextTree());
                                    adaptor.addChild(root_1, stream_arguments.nextTree());

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;
                    case 3:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1114:13: outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) )
                    {
                        outerDot = (Token) match(input, DOT, FOLLOW_DOT_in_qualifiedIdentExpression13556);
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_DOT.add(outerDot);

                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:13: ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) )
                        int alt143 = 5;
                        switch (input.LA(1))
                        {
                            case CLASS:
                            {
                                alt143 = 1;
                            }
                            break;
                            case LESS_THAN:
                            {
                                alt143 = 2;
                            }
                            break;
                            case THIS:
                            {
                                alt143 = 3;
                            }
                            break;
                            case SUPER:
                            {
                                alt143 = 4;
                            }
                            break;
                            case NEW:
                            {
                                alt143 = 5;
                            }
                            break;
                            default:
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return retval;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 143, 0, input);

                                throw nvae;
                        }

                        switch (alt143)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:17: CLASS
                            {
                                CLASS498 = (Token) match(input, CLASS, FOLLOW_CLASS_in_qualifiedIdentExpression13574);
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_CLASS.add(CLASS498);


                                // AST REWRITE
                                // elements: qualifiedIdentifier, CLASS, DOT
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1115:57: -> ^( DOT qualifiedIdentifier CLASS )
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:61: ^( DOT qualifiedIdentifier CLASS )
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                            adaptor.addChild(root_1, stream_qualifiedIdentifier.nextTree());
                                            adaptor.addChild(root_1, stream_CLASS.nextNode());

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;
                            case 2:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1116:17: genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) )
                            {
                                pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_qualifiedIdentExpression13637);
                                genericTypeArgumentListSimplified499 = genericTypeArgumentListSimplified();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                    stream_genericTypeArgumentListSimplified.add(genericTypeArgumentListSimplified499.getTree());
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:17: (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) )
                                int alt142 = 3;
                                int LA142_0 = input.LA(1);

                                if ((LA142_0 == SUPER))
                                {
                                    int LA142_1 = input.LA(2);

                                    if ((LA142_1 == DOT))
                                    {
                                        alt142 = 2;
                                    }
                                    else if ((LA142_1 == LPAREN))
                                    {
                                        alt142 = 1;
                                    }
                                    else
                                    {
                                        if (state.backtracking > 0)
                                        {
                                            state.failed = true;
                                            return retval;
                                        }
                                        NoViableAltException nvae =
                                                new NoViableAltException("", 142, 1, input);

                                        throw nvae;
                                    }
                                }
                                else if ((LA142_0 == IDENT))
                                {
                                    alt142 = 3;
                                }
                                else
                                {
                                    if (state.backtracking > 0)
                                    {
                                        state.failed = true;
                                        return retval;
                                    }
                                    NoViableAltException nvae =
                                            new NoViableAltException("", 142, 0, input);

                                    throw nvae;
                                }
                                switch (alt142)
                                {
                                    case 1:
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:21: Super= SUPER arguments
                                    {
                                        Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_qualifiedIdentExpression13661);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_SUPER.add(Super);

                                        pushFollow(FOLLOW_arguments_in_qualifiedIdentExpression13663);
                                        arguments500 = arguments();

                                        state._fsp--;
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_arguments.add(arguments500.getTree());


                                        // AST REWRITE
                                        // elements: qualifiedIdentifier, arguments, genericTypeArgumentListSimplified
                                        // token labels:
                                        // rule labels: retval
                                        // token list labels:
                                        // rule list labels:
                                        // wildcard labels:
                                        if (state.backtracking == 0)
                                        {
                                            retval.tree = root_0;
                                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                            root_0 = (CommonTree) adaptor.nil();
                                            // 1117:57: -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments )
                                            {
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:61: ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments )
                                                {
                                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(SUPER_CONSTRUCTOR_CALL, Super, "SUPER_CONSTRUCTOR_CALL"), root_1);

                                                    adaptor.addChild(root_1, stream_qualifiedIdentifier.nextTree());
                                                    adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                                    adaptor.addChild(root_1, stream_arguments.nextTree());

                                                    adaptor.addChild(root_0, root_1);
                                                }

                                            }

                                            retval.tree = root_0;
                                        }
                                    }
                                    break;
                                    case 2:
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1118:21: SUPER innerDot= DOT IDENT arguments
                                    {
                                        SUPER501 = (Token) match(input, SUPER, FOLLOW_SUPER_in_qualifiedIdentExpression13713);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_SUPER.add(SUPER501);

                                        innerDot = (Token) match(input, DOT, FOLLOW_DOT_in_qualifiedIdentExpression13717);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_DOT.add(innerDot);

                                        IDENT502 = (Token) match(input, IDENT, FOLLOW_IDENT_in_qualifiedIdentExpression13719);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_IDENT.add(IDENT502);

                                        pushFollow(FOLLOW_arguments_in_qualifiedIdentExpression13721);
                                        arguments503 = arguments();

                                        state._fsp--;
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_arguments.add(arguments503.getTree());


                                        // AST REWRITE
                                        // elements: arguments, SUPER, innerDot, genericTypeArgumentListSimplified, IDENT, qualifiedIdentifier, outerDot
                                        // token labels: outerDot, innerDot
                                        // rule labels: retval
                                        // token list labels:
                                        // rule list labels:
                                        // wildcard labels:
                                        if (state.backtracking == 0)
                                        {
                                            retval.tree = root_0;
                                            RewriteRuleTokenStream stream_outerDot = new RewriteRuleTokenStream(adaptor, "token outerDot", outerDot);
                                            RewriteRuleTokenStream stream_innerDot = new RewriteRuleTokenStream(adaptor, "token innerDot", innerDot);
                                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                            root_0 = (CommonTree) adaptor.nil();
                                            // 1118:57: -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments )
                                            {
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1118:61: ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments )
                                                {
                                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1118:75: ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT )
                                                    {
                                                        CommonTree root_2 = (CommonTree) adaptor.nil();
                                                        root_2 = (CommonTree) adaptor.becomeRoot(stream_innerDot.nextNode(), root_2);

                                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1118:87: ^( $outerDot qualifiedIdentifier SUPER )
                                                        {
                                                            CommonTree root_3 = (CommonTree) adaptor.nil();
                                                            root_3 = (CommonTree) adaptor.becomeRoot(stream_outerDot.nextNode(), root_3);

                                                            adaptor.addChild(root_3, stream_qualifiedIdentifier.nextTree());
                                                            adaptor.addChild(root_3, stream_SUPER.nextNode());

                                                            adaptor.addChild(root_2, root_3);
                                                        }
                                                        adaptor.addChild(root_2, stream_IDENT.nextNode());

                                                        adaptor.addChild(root_1, root_2);
                                                    }
                                                    adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                                    adaptor.addChild(root_1, stream_arguments.nextTree());

                                                    adaptor.addChild(root_0, root_1);
                                                }

                                            }

                                            retval.tree = root_0;
                                        }
                                    }
                                    break;
                                    case 3:
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1119:21: IDENT arguments
                                    {
                                        IDENT504 = (Token) match(input, IDENT, FOLLOW_IDENT_in_qualifiedIdentExpression13771);
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_IDENT.add(IDENT504);

                                        pushFollow(FOLLOW_arguments_in_qualifiedIdentExpression13773);
                                        arguments505 = arguments();

                                        state._fsp--;
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_arguments.add(arguments505.getTree());


                                        // AST REWRITE
                                        // elements: DOT, IDENT, qualifiedIdentifier, genericTypeArgumentListSimplified, arguments
                                        // token labels:
                                        // rule labels: retval
                                        // token list labels:
                                        // rule list labels:
                                        // wildcard labels:
                                        if (state.backtracking == 0)
                                        {
                                            retval.tree = root_0;
                                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                            root_0 = (CommonTree) adaptor.nil();
                                            // 1119:57: -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments )
                                            {
                                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1119:61: ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments )
                                                {
                                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(METHOD_CALL, "METHOD_CALL"), root_1);

                                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1119:75: ^( DOT qualifiedIdentifier IDENT )
                                                    {
                                                        CommonTree root_2 = (CommonTree) adaptor.nil();
                                                        root_2 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_2);

                                                        adaptor.addChild(root_2, stream_qualifiedIdentifier.nextTree());
                                                        adaptor.addChild(root_2, stream_IDENT.nextNode());

                                                        adaptor.addChild(root_1, root_2);
                                                    }
                                                    adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());
                                                    adaptor.addChild(root_1, stream_arguments.nextTree());

                                                    adaptor.addChild(root_0, root_1);
                                                }

                                            }

                                            retval.tree = root_0;
                                        }
                                    }
                                    break;

                                }


                            }
                            break;
                            case 3:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1121:17: THIS
                            {
                                THIS506 = (Token) match(input, THIS, FOLLOW_THIS_in_qualifiedIdentExpression13848);
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_THIS.add(THIS506);


                                // AST REWRITE
                                // elements: THIS, DOT, qualifiedIdentifier
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1121:57: -> ^( DOT qualifiedIdentifier THIS )
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1121:61: ^( DOT qualifiedIdentifier THIS )
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                            adaptor.addChild(root_1, stream_qualifiedIdentifier.nextTree());
                                            adaptor.addChild(root_1, stream_THIS.nextNode());

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;
                            case 4:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1122:17: Super= SUPER arguments
                            {
                                Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_qualifiedIdentExpression13914);
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_SUPER.add(Super);

                                pushFollow(FOLLOW_arguments_in_qualifiedIdentExpression13916);
                                arguments507 = arguments();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_arguments.add(arguments507.getTree());


                                // AST REWRITE
                                // elements: arguments, qualifiedIdentifier
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1122:57: -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments )
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1122:61: ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments )
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(SUPER_CONSTRUCTOR_CALL, Super, "SUPER_CONSTRUCTOR_CALL"), root_1);

                                            adaptor.addChild(root_1, stream_qualifiedIdentifier.nextTree());
                                            adaptor.addChild(root_1, stream_arguments.nextTree());

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;
                            case 5:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1123:17: innerNewExpression
                            {
                                pushFollow(FOLLOW_innerNewExpression_in_qualifiedIdentExpression13964);
                                innerNewExpression508 = innerNewExpression();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                    stream_innerNewExpression.add(innerNewExpression508.getTree());


                                // AST REWRITE
                                // elements: DOT, innerNewExpression, qualifiedIdentifier
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1123:57: -> ^( DOT qualifiedIdentifier innerNewExpression )
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1123:61: ^( DOT qualifiedIdentifier innerNewExpression )
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot(stream_DOT.nextNode(), root_1);

                                            adaptor.addChild(root_1, stream_qualifiedIdentifier.nextTree());
                                            adaptor.addChild(root_1, stream_innerNewExpression.nextTree());

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;

                        }


                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 106, qualifiedIdentExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "qualifiedIdentExpression"

    public static class newExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "newExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1128:1: newExpression : NEW ( primitiveType newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] primitiveType newArrayConstruction ) | ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified ( newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction ) | arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? ) ) ) ;

    public final JavaParser.newExpression_return newExpression() throws RecognitionException
    {
        JavaParser.newExpression_return retval = new JavaParser.newExpression_return();
        retval.start = input.LT(1);
        int newExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token NEW509 = null;
        JavaParser.primitiveType_return primitiveType510 = null;

        JavaParser.newArrayConstruction_return newArrayConstruction511 = null;

        JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified512 = null;

        JavaParser.qualifiedTypeIdentSimplified_return qualifiedTypeIdentSimplified513 = null;

        JavaParser.newArrayConstruction_return newArrayConstruction514 = null;

        JavaParser.arguments_return arguments515 = null;

        JavaParser.classBody_return classBody516 = null;


        CommonTree NEW509_tree = null;
        RewriteRuleTokenStream stream_NEW = new RewriteRuleTokenStream(adaptor, "token NEW");
        RewriteRuleSubtreeStream stream_newArrayConstruction = new RewriteRuleSubtreeStream(adaptor, "rule newArrayConstruction");
        RewriteRuleSubtreeStream stream_arguments = new RewriteRuleSubtreeStream(adaptor, "rule arguments");
        RewriteRuleSubtreeStream stream_qualifiedTypeIdentSimplified = new RewriteRuleSubtreeStream(adaptor, "rule qualifiedTypeIdentSimplified");
        RewriteRuleSubtreeStream stream_primitiveType = new RewriteRuleSubtreeStream(adaptor, "rule primitiveType");
        RewriteRuleSubtreeStream stream_classBody = new RewriteRuleSubtreeStream(adaptor, "rule classBody");
        RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgumentListSimplified");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 107))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1129:5: ( NEW ( primitiveType newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] primitiveType newArrayConstruction ) | ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified ( newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction ) | arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? ) ) ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1129:9: NEW ( primitiveType newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] primitiveType newArrayConstruction ) | ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified ( newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction ) | arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? ) ) )
            {
                NEW509 = (Token) match(input, NEW, FOLLOW_NEW_in_newExpression14040);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_NEW.add(NEW509);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1130:9: ( primitiveType newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] primitiveType newArrayConstruction ) | ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified ( newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction ) | arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? ) ) )
                int alt148 = 2;
                int LA148_0 = input.LA(1);

                if ((LA148_0 == BOOLEAN || LA148_0 == BYTE || LA148_0 == CHAR || LA148_0 == DOUBLE || LA148_0 == FLOAT || (LA148_0 >= INT && LA148_0 <= LONG) || LA148_0 == SHORT))
                {
                    alt148 = 1;
                }
                else if ((LA148_0 == LESS_THAN || LA148_0 == IDENT))
                {
                    alt148 = 2;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 148, 0, input);

                    throw nvae;
                }
                switch (alt148)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1130:13: primitiveType newArrayConstruction
                    {
                        pushFollow(FOLLOW_primitiveType_in_newExpression14054);
                        primitiveType510 = primitiveType();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_primitiveType.add(primitiveType510.getTree());
                        pushFollow(FOLLOW_newArrayConstruction_in_newExpression14056);
                        newArrayConstruction511 = newArrayConstruction();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_newArrayConstruction.add(newArrayConstruction511.getTree());


                        // AST REWRITE
                        // elements: newArrayConstruction, primitiveType
                        // token labels:
                        // rule labels: retval
                        // token list labels:
                        // rule list labels:
                        // wildcard labels:
                        if (state.backtracking == 0)
                        {
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                            root_0 = (CommonTree) adaptor.nil();
                            // 1131:13: -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] primitiveType newArrayConstruction )
                            {
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1131:17: ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] primitiveType newArrayConstruction )
                                {
                                    CommonTree root_1 = (CommonTree) adaptor.nil();
                                    root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(STATIC_ARRAY_CREATOR, NEW509, "STATIC_ARRAY_CREATOR"), root_1);

                                    adaptor.addChild(root_1, stream_primitiveType.nextTree());
                                    adaptor.addChild(root_1, stream_newArrayConstruction.nextTree());

                                    adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                        }
                    }
                    break;
                    case 2:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1132:13: ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified ( newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction ) | arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? ) )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1132:13: ( genericTypeArgumentListSimplified )?
                        int alt145 = 2;
                        int LA145_0 = input.LA(1);

                        if ((LA145_0 == LESS_THAN))
                        {
                            alt145 = 1;
                        }
                        switch (alt145)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeArgumentListSimplified
                            {
                                pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_newExpression14100);
                                genericTypeArgumentListSimplified512 = genericTypeArgumentListSimplified();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                    stream_genericTypeArgumentListSimplified.add(genericTypeArgumentListSimplified512.getTree());

                            }
                            break;

                        }

                        pushFollow(FOLLOW_qualifiedTypeIdentSimplified_in_newExpression14103);
                        qualifiedTypeIdentSimplified513 = qualifiedTypeIdentSimplified();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_qualifiedTypeIdentSimplified.add(qualifiedTypeIdentSimplified513.getTree());
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1133:13: ( newArrayConstruction -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction ) | arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? ) )
                        int alt147 = 2;
                        int LA147_0 = input.LA(1);

                        if ((LA147_0 == LBRACK))
                        {
                            alt147 = 1;
                        }
                        else if ((LA147_0 == LPAREN))
                        {
                            alt147 = 2;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return retval;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 147, 0, input);

                            throw nvae;
                        }
                        switch (alt147)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1133:17: newArrayConstruction
                            {
                                pushFollow(FOLLOW_newArrayConstruction_in_newExpression14121);
                                newArrayConstruction514 = newArrayConstruction();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0)
                                    stream_newArrayConstruction.add(newArrayConstruction514.getTree());


                                // AST REWRITE
                                // elements: genericTypeArgumentListSimplified, qualifiedTypeIdentSimplified, newArrayConstruction
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1134:17: -> ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction )
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1134:21: ^( STATIC_ARRAY_CREATOR[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified newArrayConstruction )
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(STATIC_ARRAY_CREATOR, NEW509, "STATIC_ARRAY_CREATOR"), root_1);

                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1134:74: ( genericTypeArgumentListSimplified )?
                                            if (stream_genericTypeArgumentListSimplified.hasNext())
                                            {
                                                adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());

                                            }
                                            stream_genericTypeArgumentListSimplified.reset();
                                            adaptor.addChild(root_1, stream_qualifiedTypeIdentSimplified.nextTree());
                                            adaptor.addChild(root_1, stream_newArrayConstruction.nextTree());

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;
                            case 2:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1135:17: arguments ( classBody )?
                            {
                                pushFollow(FOLLOW_arguments_in_newExpression14186);
                                arguments515 = arguments();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0) stream_arguments.add(arguments515.getTree());
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1135:27: ( classBody )?
                                int alt146 = 2;
                                int LA146_0 = input.LA(1);

                                if ((LA146_0 == LCURLY))
                                {
                                    alt146 = 1;
                                }
                                switch (alt146)
                                {
                                    case 1:
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: classBody
                                    {
                                        pushFollow(FOLLOW_classBody_in_newExpression14188);
                                        classBody516 = classBody();

                                        state._fsp--;
                                        if (state.failed) return retval;
                                        if (state.backtracking == 0) stream_classBody.add(classBody516.getTree());

                                    }
                                    break;

                                }


                                // AST REWRITE
                                // elements: qualifiedTypeIdentSimplified, classBody, genericTypeArgumentListSimplified, arguments
                                // token labels:
                                // rule labels: retval
                                // token list labels:
                                // rule list labels:
                                // wildcard labels:
                                if (state.backtracking == 0)
                                {
                                    retval.tree = root_0;
                                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                                    root_0 = (CommonTree) adaptor.nil();
                                    // 1136:17: -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? )
                                    {
                                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1136:21: ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? qualifiedTypeIdentSimplified arguments ( classBody )? )
                                        {
                                            CommonTree root_1 = (CommonTree) adaptor.nil();
                                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CLASS_CONSTRUCTOR_CALL, NEW509, "STATIC_ARRAY_CREATOR"), root_1);

                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1136:76: ( genericTypeArgumentListSimplified )?
                                            if (stream_genericTypeArgumentListSimplified.hasNext())
                                            {
                                                adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());

                                            }
                                            stream_genericTypeArgumentListSimplified.reset();
                                            adaptor.addChild(root_1, stream_qualifiedTypeIdentSimplified.nextTree());
                                            adaptor.addChild(root_1, stream_arguments.nextTree());
                                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1136:150: ( classBody )?
                                            if (stream_classBody.hasNext())
                                            {
                                                adaptor.addChild(root_1, stream_classBody.nextTree());

                                            }
                                            stream_classBody.reset();

                                            adaptor.addChild(root_0, root_1);
                                        }

                                    }

                                    retval.tree = root_0;
                                }
                            }
                            break;

                        }


                    }
                    break;

                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 107, newExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "newExpression"

    public static class innerNewExpression_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "innerNewExpression"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1141:1: innerNewExpression : NEW ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )? ) ;

    public final JavaParser.innerNewExpression_return innerNewExpression() throws RecognitionException
    {
        JavaParser.innerNewExpression_return retval = new JavaParser.innerNewExpression_return();
        retval.start = input.LT(1);
        int innerNewExpression_StartIndex = input.index();
        CommonTree root_0 = null;

        Token NEW517 = null;
        Token IDENT519 = null;
        JavaParser.genericTypeArgumentListSimplified_return genericTypeArgumentListSimplified518 = null;

        JavaParser.arguments_return arguments520 = null;

        JavaParser.classBody_return classBody521 = null;


        CommonTree NEW517_tree = null;
        CommonTree IDENT519_tree = null;
        RewriteRuleTokenStream stream_NEW = new RewriteRuleTokenStream(adaptor, "token NEW");
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor, "token IDENT");
        RewriteRuleSubtreeStream stream_arguments = new RewriteRuleSubtreeStream(adaptor, "rule arguments");
        RewriteRuleSubtreeStream stream_classBody = new RewriteRuleSubtreeStream(adaptor, "rule classBody");
        RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified = new RewriteRuleSubtreeStream(adaptor, "rule genericTypeArgumentListSimplified");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 108))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1142:5: ( NEW ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )? -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1142:9: NEW ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )?
            {
                NEW517 = (Token) match(input, NEW, FOLLOW_NEW_in_innerNewExpression14283);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_NEW.add(NEW517);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1142:13: ( genericTypeArgumentListSimplified )?
                int alt149 = 2;
                int LA149_0 = input.LA(1);

                if ((LA149_0 == LESS_THAN))
                {
                    alt149 = 1;
                }
                switch (alt149)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeArgumentListSimplified
                    {
                        pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_innerNewExpression14285);
                        genericTypeArgumentListSimplified518 = genericTypeArgumentListSimplified();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0)
                            stream_genericTypeArgumentListSimplified.add(genericTypeArgumentListSimplified518.getTree());

                    }
                    break;

                }

                IDENT519 = (Token) match(input, IDENT, FOLLOW_IDENT_in_innerNewExpression14288);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_IDENT.add(IDENT519);

                pushFollow(FOLLOW_arguments_in_innerNewExpression14290);
                arguments520 = arguments();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_arguments.add(arguments520.getTree());
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1142:64: ( classBody )?
                int alt150 = 2;
                int LA150_0 = input.LA(1);

                if ((LA150_0 == LCURLY))
                {
                    alt150 = 1;
                }
                switch (alt150)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: classBody
                    {
                        pushFollow(FOLLOW_classBody_in_innerNewExpression14292);
                        classBody521 = classBody();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_classBody.add(classBody521.getTree());

                    }
                    break;

                }


                // AST REWRITE
                // elements: genericTypeArgumentListSimplified, classBody, arguments, IDENT
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 1143:9: -> ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1143:13: ^( CLASS_CONSTRUCTOR_CALL[$NEW, \"STATIC_ARRAY_CREATOR\"] ( genericTypeArgumentListSimplified )? IDENT arguments ( classBody )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(CLASS_CONSTRUCTOR_CALL, NEW517, "STATIC_ARRAY_CREATOR"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1143:68: ( genericTypeArgumentListSimplified )?
                            if (stream_genericTypeArgumentListSimplified.hasNext())
                            {
                                adaptor.addChild(root_1, stream_genericTypeArgumentListSimplified.nextTree());

                            }
                            stream_genericTypeArgumentListSimplified.reset();
                            adaptor.addChild(root_1, stream_IDENT.nextNode());
                            adaptor.addChild(root_1, stream_arguments.nextTree());
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1143:119: ( classBody )?
                            if (stream_classBody.hasNext())
                            {
                                adaptor.addChild(root_1, stream_classBody.nextTree());

                            }
                            stream_classBody.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 108, innerNewExpression_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "innerNewExpression"

    public static class newArrayConstruction_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "newArrayConstruction"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1146:1: newArrayConstruction : ( arrayDeclaratorList arrayInitializer | LBRACK expression RBRACK ( LBRACK expression RBRACK )* ( arrayDeclaratorList )? );

    public final JavaParser.newArrayConstruction_return newArrayConstruction() throws RecognitionException
    {
        JavaParser.newArrayConstruction_return retval = new JavaParser.newArrayConstruction_return();
        retval.start = input.LT(1);
        int newArrayConstruction_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LBRACK524 = null;
        Token RBRACK526 = null;
        Token LBRACK527 = null;
        Token RBRACK529 = null;
        JavaParser.arrayDeclaratorList_return arrayDeclaratorList522 = null;

        JavaParser.arrayInitializer_return arrayInitializer523 = null;

        JavaParser.expression_return expression525 = null;

        JavaParser.expression_return expression528 = null;

        JavaParser.arrayDeclaratorList_return arrayDeclaratorList530 = null;


        CommonTree LBRACK524_tree = null;
        CommonTree RBRACK526_tree = null;
        CommonTree LBRACK527_tree = null;
        CommonTree RBRACK529_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 109))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1147:5: ( arrayDeclaratorList arrayInitializer | LBRACK expression RBRACK ( LBRACK expression RBRACK )* ( arrayDeclaratorList )? )
            int alt153 = 2;
            int LA153_0 = input.LA(1);

            if ((LA153_0 == LBRACK))
            {
                int LA153_1 = input.LA(2);

                if ((LA153_1 == RBRACK))
                {
                    alt153 = 1;
                }
                else if ((LA153_1 == DEC || LA153_1 == INC || LA153_1 == LESS_THAN || LA153_1 == LOGICAL_NOT || (LA153_1 >= LPAREN && LA153_1 <= MINUS) || LA153_1 == NOT || LA153_1 == PLUS || LA153_1 == BOOLEAN || LA153_1 == BYTE || LA153_1 == CHAR || LA153_1 == DOUBLE || LA153_1 == FALSE || LA153_1 == FLOAT || (LA153_1 >= INT && LA153_1 <= LONG) || (LA153_1 >= NEW && LA153_1 <= NULL) || LA153_1 == SHORT || LA153_1 == SUPER || LA153_1 == THIS || LA153_1 == TRUE || LA153_1 == VOID || (LA153_1 >= IDENT && LA153_1 <= STRING_LITERAL)))
                {
                    alt153 = 2;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 153, 1, input);

                    throw nvae;
                }
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 153, 0, input);

                throw nvae;
            }
            switch (alt153)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1147:9: arrayDeclaratorList arrayInitializer
                {
                    root_0 = (CommonTree) adaptor.nil();

                    pushFollow(FOLLOW_arrayDeclaratorList_in_newArrayConstruction14338);
                    arrayDeclaratorList522 = arrayDeclaratorList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, arrayDeclaratorList522.getTree());
                    pushFollow(FOLLOW_arrayInitializer_in_newArrayConstruction14340);
                    arrayInitializer523 = arrayInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, arrayInitializer523.getTree());

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1148:9: LBRACK expression RBRACK ( LBRACK expression RBRACK )* ( arrayDeclaratorList )?
                {
                    root_0 = (CommonTree) adaptor.nil();

                    LBRACK524 = (Token) match(input, LBRACK, FOLLOW_LBRACK_in_newArrayConstruction14350);
                    if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_newArrayConstruction14353);
                    expression525 = expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if (state.backtracking == 0) adaptor.addChild(root_0, expression525.getTree());
                    RBRACK526 = (Token) match(input, RBRACK, FOLLOW_RBRACK_in_newArrayConstruction14355);
                    if (state.failed) return retval;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1148:36: ( LBRACK expression RBRACK )*
                    loop151:
                    do
                    {
                        int alt151 = 2;
                        alt151 = dfa151.predict(input);
                        switch (alt151)
                        {
                            case 1:
                                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1148:37: LBRACK expression RBRACK
                            {
                                LBRACK527 = (Token) match(input, LBRACK, FOLLOW_LBRACK_in_newArrayConstruction14359);
                                if (state.failed) return retval;
                                pushFollow(FOLLOW_expression_in_newArrayConstruction14362);
                                expression528 = expression();

                                state._fsp--;
                                if (state.failed) return retval;
                                if (state.backtracking == 0) adaptor.addChild(root_0, expression528.getTree());
                                RBRACK529 = (Token) match(input, RBRACK, FOLLOW_RBRACK_in_newArrayConstruction14364);
                                if (state.failed) return retval;

                            }
                            break;

                            default:
                                break loop151;
                        }
                    }
                    while (true);

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1148:66: ( arrayDeclaratorList )?
                    int alt152 = 2;
                    int LA152_0 = input.LA(1);

                    if ((LA152_0 == LBRACK))
                    {
                        int LA152_1 = input.LA(2);

                        if ((LA152_1 == RBRACK))
                        {
                            alt152 = 1;
                        }
                    }
                    switch (alt152)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                        {
                            pushFollow(FOLLOW_arrayDeclaratorList_in_newArrayConstruction14369);
                            arrayDeclaratorList530 = arrayDeclaratorList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if (state.backtracking == 0) adaptor.addChild(root_0, arrayDeclaratorList530.getTree());

                        }
                        break;

                    }


                }
                break;

            }
            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 109, newArrayConstruction_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "newArrayConstruction"

    public static class arguments_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "arguments"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1151:1: arguments : LPAREN ( expressionList )? RPAREN -> ^( ARGUMENT_LIST[$LPAREN, \"ARGUMENT_LIST\"] ( expressionList )? ) ;

    public final JavaParser.arguments_return arguments() throws RecognitionException
    {
        JavaParser.arguments_return retval = new JavaParser.arguments_return();
        retval.start = input.LT(1);
        int arguments_StartIndex = input.index();
        CommonTree root_0 = null;

        Token LPAREN531 = null;
        Token RPAREN533 = null;
        JavaParser.expressionList_return expressionList532 = null;


        CommonTree LPAREN531_tree = null;
        CommonTree RPAREN533_tree = null;
        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(adaptor, "token RPAREN");
        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(adaptor, "token LPAREN");
        RewriteRuleSubtreeStream stream_expressionList = new RewriteRuleSubtreeStream(adaptor, "rule expressionList");
        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 110))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1152:5: ( LPAREN ( expressionList )? RPAREN -> ^( ARGUMENT_LIST[$LPAREN, \"ARGUMENT_LIST\"] ( expressionList )? ) )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1152:9: LPAREN ( expressionList )? RPAREN
            {
                LPAREN531 = (Token) match(input, LPAREN, FOLLOW_LPAREN_in_arguments14389);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_LPAREN.add(LPAREN531);

                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1152:16: ( expressionList )?
                int alt154 = 2;
                int LA154_0 = input.LA(1);

                if ((LA154_0 == DEC || LA154_0 == INC || LA154_0 == LESS_THAN || LA154_0 == LOGICAL_NOT || (LA154_0 >= LPAREN && LA154_0 <= MINUS) || LA154_0 == NOT || LA154_0 == PLUS || LA154_0 == BOOLEAN || LA154_0 == BYTE || LA154_0 == CHAR || LA154_0 == DOUBLE || LA154_0 == FALSE || LA154_0 == FLOAT || (LA154_0 >= INT && LA154_0 <= LONG) || (LA154_0 >= NEW && LA154_0 <= NULL) || LA154_0 == SHORT || LA154_0 == SUPER || LA154_0 == THIS || LA154_0 == TRUE || LA154_0 == VOID || (LA154_0 >= IDENT && LA154_0 <= STRING_LITERAL)))
                {
                    alt154 = 1;
                }
                switch (alt154)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: expressionList
                    {
                        pushFollow(FOLLOW_expressionList_in_arguments14391);
                        expressionList532 = expressionList();

                        state._fsp--;
                        if (state.failed) return retval;
                        if (state.backtracking == 0) stream_expressionList.add(expressionList532.getTree());

                    }
                    break;

                }

                RPAREN533 = (Token) match(input, RPAREN, FOLLOW_RPAREN_in_arguments14394);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_RPAREN.add(RPAREN533);


                // AST REWRITE
                // elements: expressionList
                // token labels:
                // rule labels: retval
                // token list labels:
                // rule list labels:
                // wildcard labels:
                if (state.backtracking == 0)
                {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);

                    root_0 = (CommonTree) adaptor.nil();
                    // 1153:9: -> ^( ARGUMENT_LIST[$LPAREN, \"ARGUMENT_LIST\"] ( expressionList )? )
                    {
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1153:13: ^( ARGUMENT_LIST[$LPAREN, \"ARGUMENT_LIST\"] ( expressionList )? )
                        {
                            CommonTree root_1 = (CommonTree) adaptor.nil();
                            root_1 = (CommonTree) adaptor.becomeRoot((CommonTree) adaptor.create(ARGUMENT_LIST, LPAREN531, "ARGUMENT_LIST"), root_1);

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1153:55: ( expressionList )?
                            if (stream_expressionList.hasNext())
                            {
                                adaptor.addChild(root_1, stream_expressionList.nextTree());

                            }
                            stream_expressionList.reset();

                            adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                }
            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 110, arguments_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "arguments"

    public static class literal_return extends ParserRuleReturnScope
    {
        CommonTree tree;

        public Object getTree()
        {
            return tree;
        }
    }

    ;

    // $ANTLR start "literal"
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1156:1: literal : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | FLOATING_POINT_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | TRUE | FALSE | NULL );

    public final JavaParser.literal_return literal() throws RecognitionException
    {
        JavaParser.literal_return retval = new JavaParser.literal_return();
        retval.start = input.LT(1);
        int literal_StartIndex = input.index();
        CommonTree root_0 = null;

        Token set534 = null;

        CommonTree set534_tree = null;

        try
        {
            if (state.backtracking > 0 && alreadyParsedRule(input, 111))
            {
                return retval;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1157:5: ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | FLOATING_POINT_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | TRUE | FALSE | NULL )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:
            {
                root_0 = (CommonTree) adaptor.nil();

                set534 = (Token) input.LT(1);
                if (input.LA(1) == FALSE || input.LA(1) == NULL || input.LA(1) == TRUE || (input.LA(1) >= HEX_LITERAL && input.LA(1) <= STRING_LITERAL))
                {
                    input.consume();
                    if (state.backtracking == 0) adaptor.addChild(root_0, (CommonTree) adaptor.create(set534));
                    state.errorRecovery = false;
                    state.failed = false;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return retval;
                    }
                    MismatchedSetException mse = new MismatchedSetException(null, input);
                    throw mse;
                }


            }

            retval.stop = input.LT(-1);

            if (state.backtracking == 0)
            {

                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re)
        {
            reportError(re);
            recover(input, re);
            retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally
        {
            if (state.backtracking > 0)
            {
                memoize(input, 111, literal_StartIndex);
            }
        }
        return retval;
    }
    // $ANTLR end "literal"

    // $ANTLR start synpred14_Java

    public final void synpred14_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:473:9: ( GREATER_THAN )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:473:9: GREATER_THAN
        {
            match(input, GREATER_THAN, FOLLOW_GREATER_THAN_in_synpred14_Java5060);
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred14_Java

    // $ANTLR start synpred15_Java

    public final void synpred15_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:474:9: ( SHIFT_RIGHT )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:474:9: SHIFT_RIGHT
        {
            match(input, SHIFT_RIGHT, FOLLOW_SHIFT_RIGHT_in_synpred15_Java5070);
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred15_Java

    // $ANTLR start synpred16_Java

    public final void synpred16_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:475:9: ( BIT_SHIFT_RIGHT )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:475:9: BIT_SHIFT_RIGHT
        {
            match(input, BIT_SHIFT_RIGHT, FOLLOW_BIT_SHIFT_RIGHT_in_synpred16_Java5080);
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred16_Java

    // $ANTLR start synpred17_Java

    public final void synpred17_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:480:15: ( bound )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:480:15: bound
        {
            pushFollow(FOLLOW_bound_in_synpred17_Java5110);
            bound();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred17_Java

    // $ANTLR start synpred33_Java

    public final void synpred33_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:537:9: ( STATIC block )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:537:9: STATIC block
        {
            match(input, STATIC, FOLLOW_STATIC_in_synpred33_Java5611);
            if (state.failed) return;
            pushFollow(FOLLOW_block_in_synpred33_Java5613);
            block();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred33_Java

    // $ANTLR start synpred43_Java

    public final void synpred43_Java_fragment() throws RecognitionException
    {
        Token ident = null;

        // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block )
        {
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( genericTypeParameterList )?
            int alt160 = 2;
            int LA160_0 = input.LA(1);

            if ((LA160_0 == LESS_THAN))
            {
                alt160 = 1;
            }
            switch (alt160)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                {
                    pushFollow(FOLLOW_genericTypeParameterList_in_synpred43_Java5650);
                    genericTypeParameterList();

                    state._fsp--;
                    if (state.failed) return;

                }
                break;

            }

            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:13: ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block )
            int alt167 = 3;
            switch (input.LA(1))
            {
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FLOAT:
                case INT:
                case LONG:
                case SHORT:
                {
                    alt167 = 1;
                }
                break;
                case IDENT:
                {
                    int LA167_2 = input.LA(2);

                    if ((LA167_2 == DOT || LA167_2 == LBRACK || LA167_2 == LESS_THAN || LA167_2 == IDENT))
                    {
                        alt167 = 1;
                    }
                    else if ((LA167_2 == LPAREN))
                    {
                        alt167 = 3;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 167, 2, input);

                        throw nvae;
                    }
                }
                break;
                case VOID:
                {
                    alt167 = 2;
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 167, 0, input);

                    throw nvae;
            }

            switch (alt167)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:17: type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI )
                {
                    pushFollow(FOLLOW_type_in_synpred43_Java5669);
                    type();

                    state._fsp--;
                    if (state.failed) return;
                    match(input, IDENT, FOLLOW_IDENT_in_synpred43_Java5671);
                    if (state.failed) return;
                    pushFollow(FOLLOW_formalParameterList_in_synpred43_Java5673);
                    formalParameterList();

                    state._fsp--;
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:48: ( arrayDeclaratorList )?
                    int alt161 = 2;
                    int LA161_0 = input.LA(1);

                    if ((LA161_0 == LBRACK))
                    {
                        alt161 = 1;
                    }
                    switch (alt161)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                        {
                            pushFollow(FOLLOW_arrayDeclaratorList_in_synpred43_Java5675);
                            arrayDeclaratorList();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:69: ( throwsClause )?
                    int alt162 = 2;
                    int LA162_0 = input.LA(1);

                    if ((LA162_0 == THROWS))
                    {
                        alt162 = 1;
                    }
                    switch (alt162)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                        {
                            pushFollow(FOLLOW_throwsClause_in_synpred43_Java5678);
                            throwsClause();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:83: ( block | SEMI )
                    int alt163 = 2;
                    int LA163_0 = input.LA(1);

                    if ((LA163_0 == LCURLY))
                    {
                        alt163 = 1;
                    }
                    else if ((LA163_0 == SEMI))
                    {
                        alt163 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 163, 0, input);

                        throw nvae;
                    }
                    switch (alt163)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:84: block
                        {
                            pushFollow(FOLLOW_block_in_synpred43_Java5682);
                            block();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:92: SEMI
                        {
                            match(input, SEMI, FOLLOW_SEMI_in_synpred43_Java5686);
                            if (state.failed) return;

                        }
                        break;

                    }


                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:17: VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI )
                {
                    match(input, VOID, FOLLOW_VOID_in_synpred43_Java5748);
                    if (state.failed) return;
                    match(input, IDENT, FOLLOW_IDENT_in_synpred43_Java5750);
                    if (state.failed) return;
                    pushFollow(FOLLOW_formalParameterList_in_synpred43_Java5752);
                    formalParameterList();

                    state._fsp--;
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:48: ( throwsClause )?
                    int alt164 = 2;
                    int LA164_0 = input.LA(1);

                    if ((LA164_0 == THROWS))
                    {
                        alt164 = 1;
                    }
                    switch (alt164)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                        {
                            pushFollow(FOLLOW_throwsClause_in_synpred43_Java5754);
                            throwsClause();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:62: ( block | SEMI )
                    int alt165 = 2;
                    int LA165_0 = input.LA(1);

                    if ((LA165_0 == LCURLY))
                    {
                        alt165 = 1;
                    }
                    else if ((LA165_0 == SEMI))
                    {
                        alt165 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 165, 0, input);

                        throw nvae;
                    }
                    switch (alt165)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:63: block
                        {
                            pushFollow(FOLLOW_block_in_synpred43_Java5758);
                            block();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:71: SEMI
                        {
                            match(input, SEMI, FOLLOW_SEMI_in_synpred43_Java5762);
                            if (state.failed) return;

                        }
                        break;

                    }


                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:544:17: ident= IDENT formalParameterList ( throwsClause )? block
                {
                    ident = (Token) match(input, IDENT, FOLLOW_IDENT_in_synpred43_Java5821);
                    if (state.failed) return;
                    pushFollow(FOLLOW_formalParameterList_in_synpred43_Java5823);
                    formalParameterList();

                    state._fsp--;
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:544:49: ( throwsClause )?
                    int alt166 = 2;
                    int LA166_0 = input.LA(1);

                    if ((LA166_0 == THROWS))
                    {
                        alt166 = 1;
                    }
                    switch (alt166)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                        {
                            pushFollow(FOLLOW_throwsClause_in_synpred43_Java5825);
                            throwsClause();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    pushFollow(FOLLOW_block_in_synpred43_Java5828);
                    block();

                    state._fsp--;
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred43_Java

    // $ANTLR start synpred44_Java

    public final void synpred44_Java_fragment() throws RecognitionException
    {
        Token ident = null;

        // /home/langera/dev/freud/trunk/src/grammar/Java.g:538:9: ( modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block ) | type classFieldDeclaratorList SEMI ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:538:9: modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block ) | type classFieldDeclaratorList SEMI )
        {
            pushFollow(FOLLOW_modifierList_in_synpred44_Java5636);
            modifierList();

            state._fsp--;
            if (state.failed) return;
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:9: ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block ) | type classFieldDeclaratorList SEMI )
            int alt176 = 2;
            switch (input.LA(1))
            {
                case LESS_THAN:
                case VOID:
                {
                    alt176 = 1;
                }
                break;
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FLOAT:
                case INT:
                case LONG:
                case SHORT:
                {
                    int LA176_2 = input.LA(2);

                    if ((synpred43_Java()))
                    {
                        alt176 = 1;
                    }
                    else if ((true))
                    {
                        alt176 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 176, 2, input);

                        throw nvae;
                    }
                }
                break;
                case IDENT:
                {
                    int LA176_3 = input.LA(2);

                    if ((synpred43_Java()))
                    {
                        alt176 = 1;
                    }
                    else if ((true))
                    {
                        alt176 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 176, 3, input);

                        throw nvae;
                    }
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 176, 0, input);

                    throw nvae;
            }

            switch (alt176)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block )
                {
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:539:13: ( genericTypeParameterList )?
                    int alt168 = 2;
                    int LA168_0 = input.LA(1);

                    if ((LA168_0 == LESS_THAN))
                    {
                        alt168 = 1;
                    }
                    switch (alt168)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                        {
                            pushFollow(FOLLOW_genericTypeParameterList_in_synpred44_Java5650);
                            genericTypeParameterList();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:13: ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) | ident= IDENT formalParameterList ( throwsClause )? block )
                    int alt175 = 3;
                    switch (input.LA(1))
                    {
                        case BOOLEAN:
                        case BYTE:
                        case CHAR:
                        case DOUBLE:
                        case FLOAT:
                        case INT:
                        case LONG:
                        case SHORT:
                        {
                            alt175 = 1;
                        }
                        break;
                        case IDENT:
                        {
                            int LA175_2 = input.LA(2);

                            if ((LA175_2 == LPAREN))
                            {
                                alt175 = 3;
                            }
                            else if ((LA175_2 == DOT || LA175_2 == LBRACK || LA175_2 == LESS_THAN || LA175_2 == IDENT))
                            {
                                alt175 = 1;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 175, 2, input);

                                throw nvae;
                            }
                        }
                        break;
                        case VOID:
                        {
                            alt175 = 2;
                        }
                        break;
                        default:
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 175, 0, input);

                            throw nvae;
                    }

                    switch (alt175)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:17: type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI )
                        {
                            pushFollow(FOLLOW_type_in_synpred44_Java5669);
                            type();

                            state._fsp--;
                            if (state.failed) return;
                            match(input, IDENT, FOLLOW_IDENT_in_synpred44_Java5671);
                            if (state.failed) return;
                            pushFollow(FOLLOW_formalParameterList_in_synpred44_Java5673);
                            formalParameterList();

                            state._fsp--;
                            if (state.failed) return;
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:48: ( arrayDeclaratorList )?
                            int alt169 = 2;
                            int LA169_0 = input.LA(1);

                            if ((LA169_0 == LBRACK))
                            {
                                alt169 = 1;
                            }
                            switch (alt169)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                                {
                                    pushFollow(FOLLOW_arrayDeclaratorList_in_synpred44_Java5675);
                                    arrayDeclaratorList();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:69: ( throwsClause )?
                            int alt170 = 2;
                            int LA170_0 = input.LA(1);

                            if ((LA170_0 == THROWS))
                            {
                                alt170 = 1;
                            }
                            switch (alt170)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                {
                                    pushFollow(FOLLOW_throwsClause_in_synpred44_Java5678);
                                    throwsClause();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:83: ( block | SEMI )
                            int alt171 = 2;
                            int LA171_0 = input.LA(1);

                            if ((LA171_0 == LCURLY))
                            {
                                alt171 = 1;
                            }
                            else if ((LA171_0 == SEMI))
                            {
                                alt171 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 171, 0, input);

                                throw nvae;
                            }
                            switch (alt171)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:84: block
                                {
                                    pushFollow(FOLLOW_block_in_synpred44_Java5682);
                                    block();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:540:92: SEMI
                                {
                                    match(input, SEMI, FOLLOW_SEMI_in_synpred44_Java5686);
                                    if (state.failed) return;

                                }
                                break;

                            }


                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:17: VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI )
                        {
                            match(input, VOID, FOLLOW_VOID_in_synpred44_Java5748);
                            if (state.failed) return;
                            match(input, IDENT, FOLLOW_IDENT_in_synpred44_Java5750);
                            if (state.failed) return;
                            pushFollow(FOLLOW_formalParameterList_in_synpred44_Java5752);
                            formalParameterList();

                            state._fsp--;
                            if (state.failed) return;
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:48: ( throwsClause )?
                            int alt172 = 2;
                            int LA172_0 = input.LA(1);

                            if ((LA172_0 == THROWS))
                            {
                                alt172 = 1;
                            }
                            switch (alt172)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                {
                                    pushFollow(FOLLOW_throwsClause_in_synpred44_Java5754);
                                    throwsClause();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:62: ( block | SEMI )
                            int alt173 = 2;
                            int LA173_0 = input.LA(1);

                            if ((LA173_0 == LCURLY))
                            {
                                alt173 = 1;
                            }
                            else if ((LA173_0 == SEMI))
                            {
                                alt173 = 2;
                            }
                            else
                            {
                                if (state.backtracking > 0)
                                {
                                    state.failed = true;
                                    return;
                                }
                                NoViableAltException nvae =
                                        new NoViableAltException("", 173, 0, input);

                                throw nvae;
                            }
                            switch (alt173)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:63: block
                                {
                                    pushFollow(FOLLOW_block_in_synpred44_Java5758);
                                    block();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;
                                case 2:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:542:71: SEMI
                                {
                                    match(input, SEMI, FOLLOW_SEMI_in_synpred44_Java5762);
                                    if (state.failed) return;

                                }
                                break;

                            }


                        }
                        break;
                        case 3:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:544:17: ident= IDENT formalParameterList ( throwsClause )? block
                        {
                            ident = (Token) match(input, IDENT, FOLLOW_IDENT_in_synpred44_Java5821);
                            if (state.failed) return;
                            pushFollow(FOLLOW_formalParameterList_in_synpred44_Java5823);
                            formalParameterList();

                            state._fsp--;
                            if (state.failed) return;
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:544:49: ( throwsClause )?
                            int alt174 = 2;
                            int LA174_0 = input.LA(1);

                            if ((LA174_0 == THROWS))
                            {
                                alt174 = 1;
                            }
                            switch (alt174)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                {
                                    pushFollow(FOLLOW_throwsClause_in_synpred44_Java5825);
                                    throwsClause();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            pushFollow(FOLLOW_block_in_synpred44_Java5828);
                            block();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }


                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:547:13: type classFieldDeclaratorList SEMI
                {
                    pushFollow(FOLLOW_type_in_synpred44_Java5892);
                    type();

                    state._fsp--;
                    if (state.failed) return;
                    pushFollow(FOLLOW_classFieldDeclaratorList_in_synpred44_Java5894);
                    classFieldDeclaratorList();

                    state._fsp--;
                    if (state.failed) return;
                    match(input, SEMI, FOLLOW_SEMI_in_synpred44_Java5896);
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred44_Java

    // $ANTLR start synpred45_Java

    public final void synpred45_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:550:9: ( typeDeclaration )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:550:9: typeDeclaration
        {
            pushFollow(FOLLOW_typeDeclaration_in_synpred45_Java5941);
            typeDeclaration();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred45_Java

    // $ANTLR start synpred51_Java

    public final void synpred51_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI )
        {
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( genericTypeParameterList )?
            int alt179 = 2;
            int LA179_0 = input.LA(1);

            if ((LA179_0 == LESS_THAN))
            {
                alt179 = 1;
            }
            switch (alt179)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                {
                    pushFollow(FOLLOW_genericTypeParameterList_in_synpred51_Java5985);
                    genericTypeParameterList();

                    state._fsp--;
                    if (state.failed) return;

                }
                break;

            }

            // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:13: ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI )
            int alt183 = 2;
            int LA183_0 = input.LA(1);

            if ((LA183_0 == BOOLEAN || LA183_0 == BYTE || LA183_0 == CHAR || LA183_0 == DOUBLE || LA183_0 == FLOAT || (LA183_0 >= INT && LA183_0 <= LONG) || LA183_0 == SHORT || LA183_0 == IDENT))
            {
                alt183 = 1;
            }
            else if ((LA183_0 == VOID))
            {
                alt183 = 2;
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 183, 0, input);

                throw nvae;
            }
            switch (alt183)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:17: type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI
                {
                    pushFollow(FOLLOW_type_in_synpred51_Java6004);
                    type();

                    state._fsp--;
                    if (state.failed) return;
                    match(input, IDENT, FOLLOW_IDENT_in_synpred51_Java6006);
                    if (state.failed) return;
                    pushFollow(FOLLOW_formalParameterList_in_synpred51_Java6008);
                    formalParameterList();

                    state._fsp--;
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:48: ( arrayDeclaratorList )?
                    int alt180 = 2;
                    int LA180_0 = input.LA(1);

                    if ((LA180_0 == LBRACK))
                    {
                        alt180 = 1;
                    }
                    switch (alt180)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                        {
                            pushFollow(FOLLOW_arrayDeclaratorList_in_synpred51_Java6010);
                            arrayDeclaratorList();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:69: ( throwsClause )?
                    int alt181 = 2;
                    int LA181_0 = input.LA(1);

                    if ((LA181_0 == THROWS))
                    {
                        alt181 = 1;
                    }
                    switch (alt181)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                        {
                            pushFollow(FOLLOW_throwsClause_in_synpred51_Java6013);
                            throwsClause();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    match(input, SEMI, FOLLOW_SEMI_in_synpred51_Java6016);
                    if (state.failed) return;

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:559:17: VOID IDENT formalParameterList ( throwsClause )? SEMI
                {
                    match(input, VOID, FOLLOW_VOID_in_synpred51_Java6074);
                    if (state.failed) return;
                    match(input, IDENT, FOLLOW_IDENT_in_synpred51_Java6076);
                    if (state.failed) return;
                    pushFollow(FOLLOW_formalParameterList_in_synpred51_Java6078);
                    formalParameterList();

                    state._fsp--;
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:559:48: ( throwsClause )?
                    int alt182 = 2;
                    int LA182_0 = input.LA(1);

                    if ((LA182_0 == THROWS))
                    {
                        alt182 = 1;
                    }
                    switch (alt182)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                        {
                            pushFollow(FOLLOW_throwsClause_in_synpred51_Java6080);
                            throwsClause();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    match(input, SEMI, FOLLOW_SEMI_in_synpred51_Java6083);
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred51_Java

    // $ANTLR start synpred52_Java

    public final void synpred52_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:555:9: ( modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI ) | type interfaceFieldDeclaratorList SEMI ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:555:9: modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI ) | type interfaceFieldDeclaratorList SEMI )
        {
            pushFollow(FOLLOW_modifierList_in_synpred52_Java5971);
            modifierList();

            state._fsp--;
            if (state.failed) return;
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:9: ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI ) | type interfaceFieldDeclaratorList SEMI )
            int alt189 = 2;
            switch (input.LA(1))
            {
                case LESS_THAN:
                case VOID:
                {
                    alt189 = 1;
                }
                break;
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FLOAT:
                case INT:
                case LONG:
                case SHORT:
                {
                    int LA189_2 = input.LA(2);

                    if ((synpred51_Java()))
                    {
                        alt189 = 1;
                    }
                    else if ((true))
                    {
                        alt189 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 189, 2, input);

                        throw nvae;
                    }
                }
                break;
                case IDENT:
                {
                    int LA189_3 = input.LA(2);

                    if ((synpred51_Java()))
                    {
                        alt189 = 1;
                    }
                    else if ((true))
                    {
                        alt189 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 189, 3, input);

                        throw nvae;
                    }
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 189, 0, input);

                    throw nvae;
            }

            switch (alt189)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI )
                {
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:556:13: ( genericTypeParameterList )?
                    int alt184 = 2;
                    int LA184_0 = input.LA(1);

                    if ((LA184_0 == LESS_THAN))
                    {
                        alt184 = 1;
                    }
                    switch (alt184)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: genericTypeParameterList
                        {
                            pushFollow(FOLLOW_genericTypeParameterList_in_synpred52_Java5985);
                            genericTypeParameterList();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:13: ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI | VOID IDENT formalParameterList ( throwsClause )? SEMI )
                    int alt188 = 2;
                    int LA188_0 = input.LA(1);

                    if ((LA188_0 == BOOLEAN || LA188_0 == BYTE || LA188_0 == CHAR || LA188_0 == DOUBLE || LA188_0 == FLOAT || (LA188_0 >= INT && LA188_0 <= LONG) || LA188_0 == SHORT || LA188_0 == IDENT))
                    {
                        alt188 = 1;
                    }
                    else if ((LA188_0 == VOID))
                    {
                        alt188 = 2;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 188, 0, input);

                        throw nvae;
                    }
                    switch (alt188)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:17: type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI
                        {
                            pushFollow(FOLLOW_type_in_synpred52_Java6004);
                            type();

                            state._fsp--;
                            if (state.failed) return;
                            match(input, IDENT, FOLLOW_IDENT_in_synpred52_Java6006);
                            if (state.failed) return;
                            pushFollow(FOLLOW_formalParameterList_in_synpred52_Java6008);
                            formalParameterList();

                            state._fsp--;
                            if (state.failed) return;
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:48: ( arrayDeclaratorList )?
                            int alt185 = 2;
                            int LA185_0 = input.LA(1);

                            if ((LA185_0 == LBRACK))
                            {
                                alt185 = 1;
                            }
                            switch (alt185)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: arrayDeclaratorList
                                {
                                    pushFollow(FOLLOW_arrayDeclaratorList_in_synpred52_Java6010);
                                    arrayDeclaratorList();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:557:69: ( throwsClause )?
                            int alt186 = 2;
                            int LA186_0 = input.LA(1);

                            if ((LA186_0 == THROWS))
                            {
                                alt186 = 1;
                            }
                            switch (alt186)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                {
                                    pushFollow(FOLLOW_throwsClause_in_synpred52_Java6013);
                                    throwsClause();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            match(input, SEMI, FOLLOW_SEMI_in_synpred52_Java6016);
                            if (state.failed) return;

                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:559:17: VOID IDENT formalParameterList ( throwsClause )? SEMI
                        {
                            match(input, VOID, FOLLOW_VOID_in_synpred52_Java6074);
                            if (state.failed) return;
                            match(input, IDENT, FOLLOW_IDENT_in_synpred52_Java6076);
                            if (state.failed) return;
                            pushFollow(FOLLOW_formalParameterList_in_synpred52_Java6078);
                            formalParameterList();

                            state._fsp--;
                            if (state.failed) return;
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:559:48: ( throwsClause )?
                            int alt187 = 2;
                            int LA187_0 = input.LA(1);

                            if ((LA187_0 == THROWS))
                            {
                                alt187 = 1;
                            }
                            switch (alt187)
                            {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: throwsClause
                                {
                                    pushFollow(FOLLOW_throwsClause_in_synpred52_Java6080);
                                    throwsClause();

                                    state._fsp--;
                                    if (state.failed) return;

                                }
                                break;

                            }

                            match(input, SEMI, FOLLOW_SEMI_in_synpred52_Java6083);
                            if (state.failed) return;

                        }
                        break;

                    }


                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:562:13: type interfaceFieldDeclaratorList SEMI
                {
                    pushFollow(FOLLOW_type_in_synpred52_Java6146);
                    type();

                    state._fsp--;
                    if (state.failed) return;
                    pushFollow(FOLLOW_interfaceFieldDeclaratorList_in_synpred52_Java6148);
                    interfaceFieldDeclaratorList();

                    state._fsp--;
                    if (state.failed) return;
                    match(input, SEMI, FOLLOW_SEMI_in_synpred52_Java6150);
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred52_Java

    // $ANTLR start synpred53_Java

    public final void synpred53_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:565:9: ( typeDeclaration )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:565:9: typeDeclaration
        {
            pushFollow(FOLLOW_typeDeclaration_in_synpred53_Java6195);
            typeDeclaration();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred53_Java

    // $ANTLR start synpred59_Java

    public final void synpred59_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:604:9: ( arrayDeclarator )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:604:9: arrayDeclarator
        {
            pushFollow(FOLLOW_arrayDeclarator_in_synpred59_Java6489);
            arrayDeclarator();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred59_Java

    // $ANTLR start synpred77_Java

    public final void synpred77_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:653:23: ( arrayDeclaratorList )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:653:23: arrayDeclaratorList
        {
            pushFollow(FOLLOW_arrayDeclaratorList_in_synpred77_Java6876);
            arrayDeclaratorList();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred77_Java

    // $ANTLR start synpred78_Java

    public final void synpred78_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:658:28: ( arrayDeclaratorList )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:658:28: arrayDeclaratorList
        {
            pushFollow(FOLLOW_arrayDeclaratorList_in_synpred78_Java6919);
            arrayDeclaratorList();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred78_Java

    // $ANTLR start synpred80_Java

    public final void synpred80_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:668:20: ( DOT typeIdent )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:668:20: DOT typeIdent
        {
            match(input, DOT, FOLLOW_DOT_in_synpred80_Java7004);
            if (state.failed) return;
            pushFollow(FOLLOW_typeIdent_in_synpred80_Java7006);
            typeIdent();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred80_Java

    // $ANTLR start synpred91_Java

    public final void synpred91_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:697:40: ( COMMA genericTypeArgument )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:697:40: COMMA genericTypeArgument
        {
            match(input, COMMA, FOLLOW_COMMA_in_synpred91_Java7229);
            if (state.failed) return;
            pushFollow(FOLLOW_genericTypeArgument_in_synpred91_Java7231);
            genericTypeArgument();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred91_Java

    // $ANTLR start synpred93_Java

    public final void synpred93_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:703:18: ( genericWildcardBoundType )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:703:18: genericWildcardBoundType
        {
            pushFollow(FOLLOW_genericWildcardBoundType_in_synpred93_Java7285);
            genericWildcardBoundType();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred93_Java

    // $ANTLR start synpred98_Java

    public final void synpred98_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:42: ( COMMA formalParameterStandardDecl )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:42: COMMA formalParameterStandardDecl
        {
            match(input, COMMA, FOLLOW_COMMA_in_synpred98_Java7486);
            if (state.failed) return;
            pushFollow(FOLLOW_formalParameterStandardDecl_in_synpred98_Java7488);
            formalParameterStandardDecl();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred98_Java

    // $ANTLR start synpred100_Java

    public final void synpred100_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:13: ( formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )? )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:13: formalParameterStandardDecl ( COMMA formalParameterStandardDecl )* ( COMMA formalParameterVarArgDecl )?
        {
            pushFollow(FOLLOW_formalParameterStandardDecl_in_synpred100_Java7483);
            formalParameterStandardDecl();

            state._fsp--;
            if (state.failed) return;
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:41: ( COMMA formalParameterStandardDecl )*
            loop192:
            do
            {
                int alt192 = 2;
                int LA192_0 = input.LA(1);

                if ((LA192_0 == COMMA))
                {
                    int LA192_1 = input.LA(2);

                    if ((synpred98_Java()))
                    {
                        alt192 = 1;
                    }


                }


                switch (alt192)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:42: COMMA formalParameterStandardDecl
                    {
                        match(input, COMMA, FOLLOW_COMMA_in_synpred100_Java7486);
                        if (state.failed) return;
                        pushFollow(FOLLOW_formalParameterStandardDecl_in_synpred100_Java7488);
                        formalParameterStandardDecl();

                        state._fsp--;
                        if (state.failed) return;

                    }
                    break;

                    default:
                        break loop192;
                }
            }
            while (true);

            // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:78: ( COMMA formalParameterVarArgDecl )?
            int alt193 = 2;
            int LA193_0 = input.LA(1);

            if ((LA193_0 == COMMA))
            {
                alt193 = 1;
            }
            switch (alt193)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:728:79: COMMA formalParameterVarArgDecl
                {
                    match(input, COMMA, FOLLOW_COMMA_in_synpred100_Java7493);
                    if (state.failed) return;
                    pushFollow(FOLLOW_formalParameterVarArgDecl_in_synpred100_Java7495);
                    formalParameterVarArgDecl();

                    state._fsp--;
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred100_Java

    // $ANTLR start synpred101_Java

    public final void synpred101_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:731:13: ( formalParameterVarArgDecl )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:731:13: formalParameterVarArgDecl
        {
            pushFollow(FOLLOW_formalParameterVarArgDecl_in_synpred101_Java7550);
            formalParameterVarArgDecl();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred101_Java

    // $ANTLR start synpred102_Java

    public final void synpred102_Java_fragment() throws RecognitionException
    {
        Token ident = null;

        // /home/langera/dev/freud/trunk/src/grammar/Java.g:752:13: ( DOT ident= IDENT )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:752:13: DOT ident= IDENT
        {
            match(input, DOT, FOLLOW_DOT_in_synpred102_Java7781);
            if (state.failed) return;
            ident = (Token) match(input, IDENT, FOLLOW_IDENT_in_synpred102_Java7785);
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred102_Java

    // $ANTLR start synpred103_Java

    public final void synpred103_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:759:9: ( annotation )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:759:9: annotation
        {
            pushFollow(FOLLOW_annotation_in_synpred103_Java7834);
            annotation();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred103_Java

    // $ANTLR start synpred115_Java

    public final void synpred115_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:810:9: ( modifierList type ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI | classFieldDeclaratorList SEMI ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:810:9: modifierList type ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI | classFieldDeclaratorList SEMI )
        {
            pushFollow(FOLLOW_modifierList_in_synpred115_Java8256);
            modifierList();

            state._fsp--;
            if (state.failed) return;
            pushFollow(FOLLOW_type_in_synpred115_Java8258);
            type();

            state._fsp--;
            if (state.failed) return;
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:811:9: ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI | classFieldDeclaratorList SEMI )
            int alt198 = 2;
            int LA198_0 = input.LA(1);

            if ((LA198_0 == IDENT))
            {
                int LA198_1 = input.LA(2);

                if ((LA198_1 == LPAREN))
                {
                    alt198 = 1;
                }
                else if ((LA198_1 == ASSIGN || LA198_1 == COMMA || LA198_1 == LBRACK || LA198_1 == SEMI))
                {
                    alt198 = 2;
                }
                else
                {
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 198, 1, input);

                    throw nvae;
                }
            }
            else
            {
                if (state.backtracking > 0)
                {
                    state.failed = true;
                    return;
                }
                NoViableAltException nvae =
                        new NoViableAltException("", 198, 0, input);

                throw nvae;
            }
            switch (alt198)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:811:13: IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI
                {
                    match(input, IDENT, FOLLOW_IDENT_in_synpred115_Java8272);
                    if (state.failed) return;
                    match(input, LPAREN, FOLLOW_LPAREN_in_synpred115_Java8274);
                    if (state.failed) return;
                    match(input, RPAREN, FOLLOW_RPAREN_in_synpred115_Java8276);
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:811:33: ( annotationDefaultValue )?
                    int alt197 = 2;
                    int LA197_0 = input.LA(1);

                    if ((LA197_0 == DEFAULT))
                    {
                        alt197 = 1;
                    }
                    switch (alt197)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:0:0: annotationDefaultValue
                        {
                            pushFollow(FOLLOW_annotationDefaultValue_in_synpred115_Java8278);
                            annotationDefaultValue();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }

                    match(input, SEMI, FOLLOW_SEMI_in_synpred115_Java8281);
                    if (state.failed) return;

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:813:13: classFieldDeclaratorList SEMI
                {
                    pushFollow(FOLLOW_classFieldDeclaratorList_in_synpred115_Java8323);
                    classFieldDeclaratorList();

                    state._fsp--;
                    if (state.failed) return;
                    match(input, SEMI, FOLLOW_SEMI_in_synpred115_Java8325);
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred115_Java

    // $ANTLR start synpred117_Java

    public final void synpred117_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:831:9: ( localVariableDeclaration SEMI )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:831:9: localVariableDeclaration SEMI
        {
            pushFollow(FOLLOW_localVariableDeclaration_in_synpred117_Java8456);
            localVariableDeclaration();

            state._fsp--;
            if (state.failed) return;
            match(input, SEMI, FOLLOW_SEMI_in_synpred117_Java8458);
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred117_Java

    // $ANTLR start synpred118_Java

    public final void synpred118_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:832:9: ( typeDeclaration )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:832:9: typeDeclaration
        {
            pushFollow(FOLLOW_typeDeclaration_in_synpred118_Java8469);
            typeDeclaration();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred118_Java

    // $ANTLR start synpred122_Java

    public final void synpred122_Java_fragment() throws RecognitionException
    {
        JavaParser.statement_return elseStat = null;


        // /home/langera/dev/freud/trunk/src/grammar/Java.g:849:13: ( ELSE elseStat= statement )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:849:13: ELSE elseStat= statement
        {
            match(input, ELSE, FOLLOW_ELSE_in_synpred122_Java8749);
            if (state.failed) return;
            pushFollow(FOLLOW_statement_in_synpred122_Java8753);
            elseStat = statement();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred122_Java

    // $ANTLR start synpred124_Java

    public final void synpred124_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:853:13: ( forInit SEMI forCondition SEMI forUpdater RPAREN statement )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:853:13: forInit SEMI forCondition SEMI forUpdater RPAREN statement
        {
            pushFollow(FOLLOW_forInit_in_synpred124_Java8932);
            forInit();

            state._fsp--;
            if (state.failed) return;
            match(input, SEMI, FOLLOW_SEMI_in_synpred124_Java8934);
            if (state.failed) return;
            pushFollow(FOLLOW_forCondition_in_synpred124_Java8936);
            forCondition();

            state._fsp--;
            if (state.failed) return;
            match(input, SEMI, FOLLOW_SEMI_in_synpred124_Java8938);
            if (state.failed) return;
            pushFollow(FOLLOW_forUpdater_in_synpred124_Java8940);
            forUpdater();

            state._fsp--;
            if (state.failed) return;
            match(input, RPAREN, FOLLOW_RPAREN_in_synpred124_Java8942);
            if (state.failed) return;
            pushFollow(FOLLOW_statement_in_synpred124_Java8944);
            statement();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred124_Java

    // $ANTLR start synpred144_Java

    public final void synpred144_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:891:9: ( switchCaseLabel )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:891:9: switchCaseLabel
        {
            pushFollow(FOLLOW_switchCaseLabel_in_synpred144_Java9890);
            switchCaseLabel();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred144_Java

    // $ANTLR start synpred147_Java

    public final void synpred147_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:903:9: ( localVariableDeclaration )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:903:9: localVariableDeclaration
        {
            pushFollow(FOLLOW_localVariableDeclaration_in_synpred147_Java9964);
            localVariableDeclaration();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred147_Java

    // $ANTLR start synpred148_Java

    public final void synpred148_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:904:9: ( expressionList )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:904:9: expressionList
        {
            pushFollow(FOLLOW_expressionList_in_synpred148_Java9986);
            expressionList();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred148_Java

    // $ANTLR start synpred191_Java

    public final void synpred191_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1040:9: ( LPAREN simpleType RPAREN unaryExpressionAll )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1040:9: LPAREN simpleType RPAREN unaryExpressionAll
        {
            match(input, LPAREN, FOLLOW_LPAREN_in_synpred191_Java11477);
            if (state.failed) return;
            pushFollow(FOLLOW_simpleType_in_synpred191_Java11479);
            simpleType();

            state._fsp--;
            if (state.failed) return;
            match(input, RPAREN, FOLLOW_RPAREN_in_synpred191_Java11481);
            if (state.failed) return;
            pushFollow(FOLLOW_unaryExpressionAll_in_synpred191_Java11483);
            unaryExpressionAll();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred191_Java

    // $ANTLR start synpred192_Java

    public final void synpred192_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1041:9: ( LPAREN objectType RPAREN unaryExpressionRest )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1041:9: LPAREN objectType RPAREN unaryExpressionRest
        {
            match(input, LPAREN, FOLLOW_LPAREN_in_synpred192_Java11509);
            if (state.failed) return;
            pushFollow(FOLLOW_objectType_in_synpred192_Java11511);
            objectType();

            state._fsp--;
            if (state.failed) return;
            match(input, RPAREN, FOLLOW_RPAREN_in_synpred192_Java11513);
            if (state.failed) return;
            pushFollow(FOLLOW_unaryExpressionRest_in_synpred192_Java11515);
            unaryExpressionRest();

            state._fsp--;
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred192_Java

    // $ANTLR start synpred220_Java

    public final void synpred220_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:13: ( ( arrayDeclarator )+ ( DOT CLASS ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:13: ( arrayDeclarator )+ ( DOT CLASS )
        {
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:13: ( arrayDeclarator )+
            int cnt221 = 0;
            loop221:
            do
            {
                int alt221 = 2;
                int LA221_0 = input.LA(1);

                if ((LA221_0 == LBRACK))
                {
                    alt221 = 1;
                }


                switch (alt221)
                {
                    case 1:
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1109:17: arrayDeclarator
                    {
                        pushFollow(FOLLOW_arrayDeclarator_in_synpred220_Java13356);
                        arrayDeclarator();

                        state._fsp--;
                        if (state.failed) return;

                    }
                    break;

                    default:
                        if (cnt221 >= 1) break loop221;
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        EarlyExitException eee =
                                new EarlyExitException(221, input);
                        throw eee;
                }
                cnt221++;
            }
            while (true);

            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1111:13: ( DOT CLASS )
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1111:17: DOT CLASS
            {
                match(input, DOT, FOLLOW_DOT_in_synpred220_Java13423);
                if (state.failed) return;
                match(input, CLASS, FOLLOW_CLASS_in_synpred220_Java13425);
                if (state.failed) return;

            }


        }
    }
    // $ANTLR end synpred220_Java

    // $ANTLR start synpred228_Java

    public final void synpred228_Java_fragment() throws RecognitionException
    {
        Token outerDot = null;
        Token Super = null;
        Token innerDot = null;

        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1114:13: (outerDot= DOT ( CLASS | genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments ) | THIS | Super= SUPER arguments | innerNewExpression ) )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1114:13: outerDot= DOT ( CLASS | genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments ) | THIS | Super= SUPER arguments | innerNewExpression )
        {
            outerDot = (Token) match(input, DOT, FOLLOW_DOT_in_synpred228_Java13556);
            if (state.failed) return;
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:13: ( CLASS | genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments ) | THIS | Super= SUPER arguments | innerNewExpression )
            int alt224 = 5;
            switch (input.LA(1))
            {
                case CLASS:
                {
                    alt224 = 1;
                }
                break;
                case LESS_THAN:
                {
                    alt224 = 2;
                }
                break;
                case THIS:
                {
                    alt224 = 3;
                }
                break;
                case SUPER:
                {
                    alt224 = 4;
                }
                break;
                case NEW:
                {
                    alt224 = 5;
                }
                break;
                default:
                    if (state.backtracking > 0)
                    {
                        state.failed = true;
                        return;
                    }
                    NoViableAltException nvae =
                            new NoViableAltException("", 224, 0, input);

                    throw nvae;
            }

            switch (alt224)
            {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:17: CLASS
                {
                    match(input, CLASS, FOLLOW_CLASS_in_synpred228_Java13574);
                    if (state.failed) return;

                }
                break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1116:17: genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments )
                {
                    pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_synpred228_Java13637);
                    genericTypeArgumentListSimplified();

                    state._fsp--;
                    if (state.failed) return;
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:17: (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments )
                    int alt223 = 3;
                    int LA223_0 = input.LA(1);

                    if ((LA223_0 == SUPER))
                    {
                        int LA223_1 = input.LA(2);

                        if ((LA223_1 == DOT))
                        {
                            alt223 = 2;
                        }
                        else if ((LA223_1 == LPAREN))
                        {
                            alt223 = 1;
                        }
                        else
                        {
                            if (state.backtracking > 0)
                            {
                                state.failed = true;
                                return;
                            }
                            NoViableAltException nvae =
                                    new NoViableAltException("", 223, 1, input);

                            throw nvae;
                        }
                    }
                    else if ((LA223_0 == IDENT))
                    {
                        alt223 = 3;
                    }
                    else
                    {
                        if (state.backtracking > 0)
                        {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae =
                                new NoViableAltException("", 223, 0, input);

                        throw nvae;
                    }
                    switch (alt223)
                    {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:21: Super= SUPER arguments
                        {
                            Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_synpred228_Java13661);
                            if (state.failed) return;
                            pushFollow(FOLLOW_arguments_in_synpred228_Java13663);
                            arguments();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1118:21: SUPER innerDot= DOT IDENT arguments
                        {
                            match(input, SUPER, FOLLOW_SUPER_in_synpred228_Java13713);
                            if (state.failed) return;
                            innerDot = (Token) match(input, DOT, FOLLOW_DOT_in_synpred228_Java13717);
                            if (state.failed) return;
                            match(input, IDENT, FOLLOW_IDENT_in_synpred228_Java13719);
                            if (state.failed) return;
                            pushFollow(FOLLOW_arguments_in_synpred228_Java13721);
                            arguments();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;
                        case 3:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1119:21: IDENT arguments
                        {
                            match(input, IDENT, FOLLOW_IDENT_in_synpred228_Java13771);
                            if (state.failed) return;
                            pushFollow(FOLLOW_arguments_in_synpred228_Java13773);
                            arguments();

                            state._fsp--;
                            if (state.failed) return;

                        }
                        break;

                    }


                }
                break;
                case 3:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1121:17: THIS
                {
                    match(input, THIS, FOLLOW_THIS_in_synpred228_Java13848);
                    if (state.failed) return;

                }
                break;
                case 4:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1122:17: Super= SUPER arguments
                {
                    Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_synpred228_Java13914);
                    if (state.failed) return;
                    pushFollow(FOLLOW_arguments_in_synpred228_Java13916);
                    arguments();

                    state._fsp--;
                    if (state.failed) return;

                }
                break;
                case 5:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1123:17: innerNewExpression
                {
                    pushFollow(FOLLOW_innerNewExpression_in_synpred228_Java13964);
                    innerNewExpression();

                    state._fsp--;
                    if (state.failed) return;

                }
                break;

            }


        }
    }
    // $ANTLR end synpred228_Java

    // $ANTLR start synpred236_Java

    public final void synpred236_Java_fragment() throws RecognitionException
    {
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1148:37: ( LBRACK expression RBRACK )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1148:37: LBRACK expression RBRACK
        {
            match(input, LBRACK, FOLLOW_LBRACK_in_synpred236_Java14359);
            if (state.failed) return;
            pushFollow(FOLLOW_expression_in_synpred236_Java14362);
            expression();

            state._fsp--;
            if (state.failed) return;
            match(input, RBRACK, FOLLOW_RBRACK_in_synpred236_Java14364);
            if (state.failed) return;

        }
    }
    // $ANTLR end synpred236_Java

    // Delegated rules

    public final boolean synpred43_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred43_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred98_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred98_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred80_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred80_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred220_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred220_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred102_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred102_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred191_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred191_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred144_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred144_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred148_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred148_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred117_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred117_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred101_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred101_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred16_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred16_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred147_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred147_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred91_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred91_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred59_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred59_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred45_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred45_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred77_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred77_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred51_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred51_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred124_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred124_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred100_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred100_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred53_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred53_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred78_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred78_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred52_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred52_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred236_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred236_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred15_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred15_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred17_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred17_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred192_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred192_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred122_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred122_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred93_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred93_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred14_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred14_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred103_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred103_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred33_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred33_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred228_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred228_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred44_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred44_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred115_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred115_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }

    public final boolean synpred118_Java()
    {
        state.backtracking++;
        int start = input.mark();
        try
        {
            synpred118_Java_fragment(); // can never throw exception
        }
        catch (RecognitionException re)
        {
            System.err.println("impossible: " + re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed = false;
        return success;
    }


    protected DFA37 dfa37 = new DFA37(this);
    protected DFA44 dfa44 = new DFA44(this);
    protected DFA87 dfa87 = new DFA87(this);
    protected DFA89 dfa89 = new DFA89(this);
    protected DFA98 dfa98 = new DFA98(this);
    protected DFA92 dfa92 = new DFA92(this);
    protected DFA104 dfa104 = new DFA104(this);
    protected DFA128 dfa128 = new DFA128(this);
    protected DFA140 dfa140 = new DFA140(this);
    protected DFA144 dfa144 = new DFA144(this);
    protected DFA151 dfa151 = new DFA151(this);
    static final String DFA37_eotS =
            "\27\uffff";
    static final String DFA37_eofS =
            "\27\uffff";
    static final String DFA37_minS =
            "\1\7\1\uffff\14\0\11\uffff";
    static final String DFA37_maxS =
            "\1\u00a4\1\uffff\14\0\11\uffff";
    static final String DFA37_acceptS =
            "\1\uffff\1\1\14\uffff\1\3\3\uffff\1\4\2\uffff\1\5\1\2";
    static final String DFA37_specialS =
            "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\11" +
                    "\uffff}>";
    static final String[] DFA37_transitionS = {
            "\1\15\17\uffff\1\1\1\uffff\1\16\22\uffff\1\25\10\uffff\1\6\1" +
                    "\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1\22\3\uffff\1\16\1\uffff" +
                    "\1\22\2\uffff\1\14\1\uffff\1\16\4\uffff\1\22\1\uffff\2\16\1" +
                    "\7\3\uffff\1\5\1\4\1\3\1\uffff\1\16\1\2\1\13\2\uffff\1\10\3" +
                    "\uffff\1\11\2\uffff\1\16\1\12\75\uffff\1\16",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA37_eot = DFA.unpackEncodedString(DFA37_eotS);
    static final short[] DFA37_eof = DFA.unpackEncodedString(DFA37_eofS);
    static final char[] DFA37_min = DFA.unpackEncodedStringToUnsignedChars(DFA37_minS);
    static final char[] DFA37_max = DFA.unpackEncodedStringToUnsignedChars(DFA37_maxS);
    static final short[] DFA37_accept = DFA.unpackEncodedString(DFA37_acceptS);
    static final short[] DFA37_special = DFA.unpackEncodedString(DFA37_specialS);
    static final short[][] DFA37_transition;

    static
    {
        int numStates = DFA37_transitionS.length;
        DFA37_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA37_transition[i] = DFA.unpackEncodedString(DFA37_transitionS[i]);
        }
    }

    class DFA37 extends DFA
    {

        public DFA37(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 37;
            this.eot = DFA37_eot;
            this.eof = DFA37_eof;
            this.min = DFA37_min;
            this.max = DFA37_max;
            this.accept = DFA37_accept;
            this.special = DFA37_special;
            this.transition = DFA37_transition;
        }

        public String getDescription()
        {
            return "535:1: classScopeDeclarations : ( block -> ^( CLASS_INSTANCE_INITIALIZER block ) | STATIC block -> ^( CLASS_STATIC_INITIALIZER[$STATIC, \"CLASS_STATIC_INITIALIZER\"] block ) | modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block | SEMI ) -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ( block )? ) | VOID IDENT formalParameterList ( throwsClause )? ( block | SEMI ) -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ( block )? ) | ident= IDENT formalParameterList ( throwsClause )? block -> ^( CONSTRUCTOR_DECL[$ident, \"CONSTRUCTOR_DECL\"] modifierList ( genericTypeParameterList )? formalParameterList ( throwsClause )? block ) ) | type classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) ) | typeDeclaration | SEMI );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA37_2 = input.LA(1);


                    int index37_2 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred33_Java()))
                    {
                        s = 22;
                    }

                    else if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_2);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA37_3 = input.LA(1);


                    int index37_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_3);
                    if (s >= 0) return s;
                    break;
                case 2:
                    int LA37_4 = input.LA(1);


                    int index37_4 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_4);
                    if (s >= 0) return s;
                    break;
                case 3:
                    int LA37_5 = input.LA(1);


                    int index37_5 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_5);
                    if (s >= 0) return s;
                    break;
                case 4:
                    int LA37_6 = input.LA(1);


                    int index37_6 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_6);
                    if (s >= 0) return s;
                    break;
                case 5:
                    int LA37_7 = input.LA(1);


                    int index37_7 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_7);
                    if (s >= 0) return s;
                    break;
                case 6:
                    int LA37_8 = input.LA(1);


                    int index37_8 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_8);
                    if (s >= 0) return s;
                    break;
                case 7:
                    int LA37_9 = input.LA(1);


                    int index37_9 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_9);
                    if (s >= 0) return s;
                    break;
                case 8:
                    int LA37_10 = input.LA(1);


                    int index37_10 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_10);
                    if (s >= 0) return s;
                    break;
                case 9:
                    int LA37_11 = input.LA(1);


                    int index37_11 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_11);
                    if (s >= 0) return s;
                    break;
                case 10:
                    int LA37_12 = input.LA(1);


                    int index37_12 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_12);
                    if (s >= 0) return s;
                    break;
                case 11:
                    int LA37_13 = input.LA(1);


                    int index37_13 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred44_Java()))
                    {
                        s = 14;
                    }

                    else if ((synpred45_Java()))
                    {
                        s = 18;
                    }


                    input.seek(index37_13);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 37, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA44_eotS =
            "\25\uffff";
    static final String DFA44_eofS =
            "\25\uffff";
    static final String DFA44_minS =
            "\1\7\14\0\10\uffff";
    static final String DFA44_maxS =
            "\1\u00a4\14\0\10\uffff";
    static final String DFA44_acceptS =
            "\15\uffff\1\1\3\uffff\1\2\2\uffff\1\3";
    static final String DFA44_specialS =
            "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\10" +
                    "\uffff}>";
    static final String[] DFA44_transitionS = {
            "\1\14\21\uffff\1\15\22\uffff\1\24\10\uffff\1\5\1\uffff\1\15" +
                    "\1\uffff\1\15\2\uffff\1\15\1\21\3\uffff\1\15\1\uffff\1\21\2" +
                    "\uffff\1\13\1\uffff\1\15\4\uffff\1\21\1\uffff\2\15\1\6\3\uffff" +
                    "\1\3\1\2\1\1\1\uffff\1\15\1\4\1\12\2\uffff\1\7\3\uffff\1\10" +
                    "\2\uffff\1\15\1\11\75\uffff\1\15",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA44_eot = DFA.unpackEncodedString(DFA44_eotS);
    static final short[] DFA44_eof = DFA.unpackEncodedString(DFA44_eofS);
    static final char[] DFA44_min = DFA.unpackEncodedStringToUnsignedChars(DFA44_minS);
    static final char[] DFA44_max = DFA.unpackEncodedStringToUnsignedChars(DFA44_maxS);
    static final short[] DFA44_accept = DFA.unpackEncodedString(DFA44_acceptS);
    static final short[] DFA44_special = DFA.unpackEncodedString(DFA44_specialS);
    static final short[][] DFA44_transition;

    static
    {
        int numStates = DFA44_transitionS.length;
        DFA44_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA44_transition[i] = DFA.unpackEncodedString(DFA44_transitionS[i]);
        }
    }

    class DFA44 extends DFA
    {

        public DFA44(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 44;
            this.eot = DFA44_eot;
            this.eof = DFA44_eof;
            this.min = DFA44_min;
            this.max = DFA44_max;
            this.accept = DFA44_accept;
            this.special = DFA44_special;
            this.transition = DFA44_transition;
        }

        public String getDescription()
        {
            return "554:1: interfaceScopeDeclarations : ( modifierList ( ( genericTypeParameterList )? ( type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? SEMI -> ^( FUNCTION_METHOD_DECL modifierList ( genericTypeParameterList )? type IDENT formalParameterList ( arrayDeclaratorList )? ( throwsClause )? ) | VOID IDENT formalParameterList ( throwsClause )? SEMI -> ^( VOID_METHOD_DECL modifierList ( genericTypeParameterList )? IDENT formalParameterList ( throwsClause )? ) ) | type interfaceFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type interfaceFieldDeclaratorList ) ) | typeDeclaration | SEMI );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA44_1 = input.LA(1);


                    int index44_1 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_1);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA44_2 = input.LA(1);


                    int index44_2 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_2);
                    if (s >= 0) return s;
                    break;
                case 2:
                    int LA44_3 = input.LA(1);


                    int index44_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_3);
                    if (s >= 0) return s;
                    break;
                case 3:
                    int LA44_4 = input.LA(1);


                    int index44_4 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_4);
                    if (s >= 0) return s;
                    break;
                case 4:
                    int LA44_5 = input.LA(1);


                    int index44_5 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_5);
                    if (s >= 0) return s;
                    break;
                case 5:
                    int LA44_6 = input.LA(1);


                    int index44_6 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_6);
                    if (s >= 0) return s;
                    break;
                case 6:
                    int LA44_7 = input.LA(1);


                    int index44_7 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_7);
                    if (s >= 0) return s;
                    break;
                case 7:
                    int LA44_8 = input.LA(1);


                    int index44_8 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_8);
                    if (s >= 0) return s;
                    break;
                case 8:
                    int LA44_9 = input.LA(1);


                    int index44_9 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_9);
                    if (s >= 0) return s;
                    break;
                case 9:
                    int LA44_10 = input.LA(1);


                    int index44_10 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_10);
                    if (s >= 0) return s;
                    break;
                case 10:
                    int LA44_11 = input.LA(1);


                    int index44_11 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_11);
                    if (s >= 0) return s;
                    break;
                case 11:
                    int LA44_12 = input.LA(1);


                    int index44_12 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred52_Java()))
                    {
                        s = 13;
                    }

                    else if ((synpred53_Java()))
                    {
                        s = 17;
                    }


                    input.seek(index44_12);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 44, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA87_eotS =
            "\22\uffff";
    static final String DFA87_eofS =
            "\22\uffff";
    static final String DFA87_minS =
            "\1\7\14\0\5\uffff";
    static final String DFA87_maxS =
            "\1\u00a4\14\0\5\uffff";
    static final String DFA87_acceptS =
            "\15\uffff\1\1\1\uffff\1\2\2\uffff";
    static final String DFA87_specialS =
            "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\5\uffff}>";
    static final String[] DFA87_transitionS = {
            "\1\14\55\uffff\1\5\1\uffff\1\15\1\uffff\1\15\2\uffff\1\15\1" +
                    "\17\3\uffff\1\15\1\uffff\1\17\2\uffff\1\13\1\uffff\1\15\4\uffff" +
                    "\1\17\1\uffff\2\15\1\6\3\uffff\1\3\1\2\1\1\1\uffff\1\15\1\4" +
                    "\1\12\2\uffff\1\7\3\uffff\1\10\3\uffff\1\11\75\uffff\1\15",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA87_eot = DFA.unpackEncodedString(DFA87_eotS);
    static final short[] DFA87_eof = DFA.unpackEncodedString(DFA87_eofS);
    static final char[] DFA87_min = DFA.unpackEncodedStringToUnsignedChars(DFA87_minS);
    static final char[] DFA87_max = DFA.unpackEncodedStringToUnsignedChars(DFA87_maxS);
    static final short[] DFA87_accept = DFA.unpackEncodedString(DFA87_acceptS);
    static final short[] DFA87_special = DFA.unpackEncodedString(DFA87_specialS);
    static final short[][] DFA87_transition;

    static
    {
        int numStates = DFA87_transitionS.length;
        DFA87_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA87_transition[i] = DFA.unpackEncodedString(DFA87_transitionS[i]);
        }
    }

    class DFA87 extends DFA
    {

        public DFA87(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 87;
            this.eot = DFA87_eot;
            this.eof = DFA87_eof;
            this.min = DFA87_min;
            this.max = DFA87_max;
            this.accept = DFA87_accept;
            this.special = DFA87_special;
            this.transition = DFA87_transition;
        }

        public String getDescription()
        {
            return "809:1: annotationScopeDeclarations : ( modifierList type ( IDENT LPAREN RPAREN ( annotationDefaultValue )? SEMI -> ^( ANNOTATION_METHOD_DECL modifierList type IDENT ( annotationDefaultValue )? ) | classFieldDeclaratorList SEMI -> ^( VAR_DECLARATION modifierList type classFieldDeclaratorList ) ) | typeDeclaration );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA87_1 = input.LA(1);


                    int index87_1 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_1);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA87_2 = input.LA(1);


                    int index87_2 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_2);
                    if (s >= 0) return s;
                    break;
                case 2:
                    int LA87_3 = input.LA(1);


                    int index87_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_3);
                    if (s >= 0) return s;
                    break;
                case 3:
                    int LA87_4 = input.LA(1);


                    int index87_4 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_4);
                    if (s >= 0) return s;
                    break;
                case 4:
                    int LA87_5 = input.LA(1);


                    int index87_5 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_5);
                    if (s >= 0) return s;
                    break;
                case 5:
                    int LA87_6 = input.LA(1);


                    int index87_6 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_6);
                    if (s >= 0) return s;
                    break;
                case 6:
                    int LA87_7 = input.LA(1);


                    int index87_7 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_7);
                    if (s >= 0) return s;
                    break;
                case 7:
                    int LA87_8 = input.LA(1);


                    int index87_8 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_8);
                    if (s >= 0) return s;
                    break;
                case 8:
                    int LA87_9 = input.LA(1);


                    int index87_9 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_9);
                    if (s >= 0) return s;
                    break;
                case 9:
                    int LA87_10 = input.LA(1);


                    int index87_10 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_10);
                    if (s >= 0) return s;
                    break;
                case 10:
                    int LA87_11 = input.LA(1);


                    int index87_11 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_11);
                    if (s >= 0) return s;
                    break;
                case 11:
                    int LA87_12 = input.LA(1);


                    int index87_12 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred115_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 15;
                    }


                    input.seek(index87_12);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 87, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA89_eotS =
            "\55\uffff";
    static final String DFA89_eofS =
            "\55\uffff";
    static final String DFA89_minS =
            "\1\7\4\0\6\uffff\1\0\41\uffff";
    static final String DFA89_maxS =
            "\1\u00aa\4\0\6\uffff\1\0\41\uffff";
    static final String DFA89_acceptS =
            "\5\uffff\1\2\14\uffff\1\3\31\uffff\1\1";
    static final String DFA89_specialS =
            "\1\uffff\1\0\1\1\1\2\1\3\6\uffff\1\4\41\uffff}>";
    static final String[] DFA89_transitionS = {
            "\1\2\4\uffff\1\22\10\uffff\1\22\1\uffff\1\22\1\uffff\1\22\1" +
                    "\uffff\1\22\1\uffff\2\22\3\uffff\1\22\3\uffff\1\22\5\uffff\1" +
                    "\22\10\uffff\1\5\1\22\1\3\1\22\1\3\2\uffff\1\3\1\5\1\22\1\uffff" +
                    "\1\22\1\3\1\uffff\1\5\1\uffff\1\22\1\1\1\uffff\1\3\2\22\2\uffff" +
                    "\1\5\1\uffff\2\3\1\5\2\22\1\uffff\3\5\1\22\1\3\2\5\2\22\1\13" +
                    "\2\22\1\uffff\1\5\3\22\1\5\1\22\74\uffff\1\4\6\22",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA89_eot = DFA.unpackEncodedString(DFA89_eotS);
    static final short[] DFA89_eof = DFA.unpackEncodedString(DFA89_eofS);
    static final char[] DFA89_min = DFA.unpackEncodedStringToUnsignedChars(DFA89_minS);
    static final char[] DFA89_max = DFA.unpackEncodedStringToUnsignedChars(DFA89_maxS);
    static final short[] DFA89_accept = DFA.unpackEncodedString(DFA89_acceptS);
    static final short[] DFA89_special = DFA.unpackEncodedString(DFA89_specialS);
    static final short[][] DFA89_transition;

    static
    {
        int numStates = DFA89_transitionS.length;
        DFA89_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA89_transition[i] = DFA.unpackEncodedString(DFA89_transitionS[i]);
        }
    }

    class DFA89 extends DFA
    {

        public DFA89(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 89;
            this.eot = DFA89_eot;
            this.eof = DFA89_eof;
            this.min = DFA89_min;
            this.max = DFA89_max;
            this.accept = DFA89_accept;
            this.special = DFA89_special;
            this.transition = DFA89_transition;
        }

        public String getDescription()
        {
            return "830:1: blockStatement : ( localVariableDeclaration SEMI | typeDeclaration | statement );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA89_1 = input.LA(1);


                    int index89_1 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred117_Java()))
                    {
                        s = 44;
                    }

                    else if ((synpred118_Java()))
                    {
                        s = 5;
                    }


                    input.seek(index89_1);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA89_2 = input.LA(1);


                    int index89_2 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred117_Java()))
                    {
                        s = 44;
                    }

                    else if ((synpred118_Java()))
                    {
                        s = 5;
                    }


                    input.seek(index89_2);
                    if (s >= 0) return s;
                    break;
                case 2:
                    int LA89_3 = input.LA(1);


                    int index89_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred117_Java()))
                    {
                        s = 44;
                    }

                    else if ((true))
                    {
                        s = 18;
                    }


                    input.seek(index89_3);
                    if (s >= 0) return s;
                    break;
                case 3:
                    int LA89_4 = input.LA(1);


                    int index89_4 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred117_Java()))
                    {
                        s = 44;
                    }

                    else if ((true))
                    {
                        s = 18;
                    }


                    input.seek(index89_4);
                    if (s >= 0) return s;
                    break;
                case 4:
                    int LA89_11 = input.LA(1);


                    int index89_11 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred118_Java()))
                    {
                        s = 5;
                    }

                    else if ((true))
                    {
                        s = 18;
                    }


                    input.seek(index89_11);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 89, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA98_eotS =
            "\22\uffff";
    static final String DFA98_eofS =
            "\22\uffff";
    static final String DFA98_minS =
            "\1\14\15\uffff\1\4\3\uffff";
    static final String DFA98_maxS =
            "\1\u00aa\15\uffff\1\114\3\uffff";
    static final String DFA98_acceptS =
            "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1" +
                    "\15\1\uffff\1\17\1\20\1\16";
    static final String DFA98_specialS =
            "\22\uffff}>";
    static final String[] DFA98_transitionS = {
            "\1\17\10\uffff\1\17\1\uffff\1\1\1\uffff\1\17\1\uffff\1\17\1" +
                    "\uffff\2\17\3\uffff\1\17\3\uffff\1\17\5\uffff\1\20\11\uffff" +
                    "\1\2\1\17\1\14\1\17\2\uffff\1\17\1\uffff\1\15\1\uffff\1\6\1" +
                    "\17\3\uffff\1\17\2\uffff\1\17\1\4\1\3\4\uffff\2\17\1\uffff\2" +
                    "\17\4\uffff\1\12\1\17\2\uffff\1\17\1\10\1\11\1\17\1\13\2\uffff" +
                    "\1\17\1\7\1\17\1\uffff\1\5\74\uffff\1\16\6\17",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\3\17\1\uffff\2\17\1\21\1\uffff\4\17\2\uffff\5\17\1\uffff\3" +
                    "\17\1\uffff\6\17\1\uffff\6\17\3\uffff\11\17\27\uffff\1\17",
            "",
            "",
            ""
    };

    static final short[] DFA98_eot = DFA.unpackEncodedString(DFA98_eotS);
    static final short[] DFA98_eof = DFA.unpackEncodedString(DFA98_eofS);
    static final char[] DFA98_min = DFA.unpackEncodedStringToUnsignedChars(DFA98_minS);
    static final char[] DFA98_max = DFA.unpackEncodedStringToUnsignedChars(DFA98_maxS);
    static final short[] DFA98_accept = DFA.unpackEncodedString(DFA98_acceptS);
    static final short[] DFA98_special = DFA.unpackEncodedString(DFA98_specialS);
    static final short[][] DFA98_transition;

    static
    {
        int numStates = DFA98_transitionS.length;
        DFA98_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA98_transition[i] = DFA.unpackEncodedString(DFA98_transitionS[i]);
        }
    }

    class DFA98 extends DFA
    {

        public DFA98(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 98;
            this.eot = DFA98_eot;
            this.eof = DFA98_eof;
            this.min = DFA98_min;
            this.max = DFA98_max;
            this.accept = DFA98_accept;
            this.special = DFA98_special;
            this.transition = DFA98_transition;
        }

        public String getDescription()
        {
            return "842:1: statement : ( block | ASSERT expr1= expression ( COLON expr2= expression SEMI -> ^( ASSERT $expr1 $expr2) | SEMI -> ^( ASSERT $expr1) ) | IF parenthesizedExpression ifStat= statement ( ELSE elseStat= statement -> ^( IF parenthesizedExpression $ifStat $elseStat) | -> ^( IF parenthesizedExpression $ifStat) ) | FOR LPAREN ( forInit SEMI forCondition SEMI forUpdater RPAREN statement -> ^( FOR forInit forCondition forUpdater statement ) | localModifierList type IDENT COLON expression RPAREN statement -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement ) ) | WHILE parenthesizedExpression statement -> ^( WHILE parenthesizedExpression statement ) | DO statement WHILE parenthesizedExpression SEMI -> ^( DO statement parenthesizedExpression ) | TRY block ( catches ( finallyClause )? | finallyClause ) -> ^( TRY block ( catches )? ( finallyClause )? ) | SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY -> ^( SWITCH parenthesizedExpression switchBlockLabels ) | SYNCHRONIZED parenthesizedExpression block -> ^( SYNCHRONIZED parenthesizedExpression block ) | RETURN ( expression )? SEMI -> ^( RETURN ( expression )? ) | THROW expression SEMI -> ^( THROW expression ) | BREAK ( IDENT )? SEMI -> ^( BREAK ( IDENT )? ) | CONTINUE ( IDENT )? SEMI -> ^( CONTINUE ( IDENT )? ) | IDENT COLON statement -> ^( LABELED_STATEMENT IDENT statement ) | expression SEMI | SEMI );";
        }
    }

    static final String DFA92_eotS =
            "\24\uffff";
    static final String DFA92_eofS =
            "\24\uffff";
    static final String DFA92_minS =
            "\1\7\4\0\17\uffff";
    static final String DFA92_maxS =
            "\1\u00aa\4\0\17\uffff";
    static final String DFA92_acceptS =
            "\5\uffff\1\1\15\uffff\1\2";
    static final String DFA92_specialS =
            "\1\uffff\1\0\1\1\1\2\1\3\17\uffff}>";
    static final String[] DFA92_transitionS = {
            "\1\2\4\uffff\1\5\10\uffff\1\5\3\uffff\1\5\1\uffff\1\5\1\uffff" +
                    "\2\5\3\uffff\1\5\3\uffff\1\5\5\uffff\1\5\12\uffff\1\3\1\uffff" +
                    "\1\3\2\uffff\1\3\4\uffff\1\3\3\uffff\1\5\1\1\1\uffff\1\3\6\uffff" +
                    "\2\3\1\uffff\2\5\5\uffff\1\3\2\uffff\1\5\2\uffff\1\5\3\uffff" +
                    "\1\5\1\uffff\1\5\76\uffff\1\4\6\5",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA92_eot = DFA.unpackEncodedString(DFA92_eotS);
    static final short[] DFA92_eof = DFA.unpackEncodedString(DFA92_eofS);
    static final char[] DFA92_min = DFA.unpackEncodedStringToUnsignedChars(DFA92_minS);
    static final char[] DFA92_max = DFA.unpackEncodedStringToUnsignedChars(DFA92_maxS);
    static final short[] DFA92_accept = DFA.unpackEncodedString(DFA92_acceptS);
    static final short[] DFA92_special = DFA.unpackEncodedString(DFA92_specialS);
    static final short[][] DFA92_transition;

    static
    {
        int numStates = DFA92_transitionS.length;
        DFA92_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA92_transition[i] = DFA.unpackEncodedString(DFA92_transitionS[i]);
        }
    }

    class DFA92 extends DFA
    {

        public DFA92(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 92;
            this.eot = DFA92_eot;
            this.eof = DFA92_eof;
            this.min = DFA92_min;
            this.max = DFA92_max;
            this.accept = DFA92_accept;
            this.special = DFA92_special;
            this.transition = DFA92_transition;
        }

        public String getDescription()
        {
            return "853:9: ( forInit SEMI forCondition SEMI forUpdater RPAREN statement -> ^( FOR forInit forCondition forUpdater statement ) | localModifierList type IDENT COLON expression RPAREN statement -> ^( FOR_EACH[$FOR, \"FOR_EACH\"] localModifierList type IDENT expression statement ) )";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA92_1 = input.LA(1);


                    int index92_1 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred124_Java()))
                    {
                        s = 5;
                    }

                    else if ((true))
                    {
                        s = 19;
                    }


                    input.seek(index92_1);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA92_2 = input.LA(1);


                    int index92_2 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred124_Java()))
                    {
                        s = 5;
                    }

                    else if ((true))
                    {
                        s = 19;
                    }


                    input.seek(index92_2);
                    if (s >= 0) return s;
                    break;
                case 2:
                    int LA92_3 = input.LA(1);


                    int index92_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred124_Java()))
                    {
                        s = 5;
                    }

                    else if ((true))
                    {
                        s = 19;
                    }


                    input.seek(index92_3);
                    if (s >= 0) return s;
                    break;
                case 3:
                    int LA92_4 = input.LA(1);


                    int index92_4 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred124_Java()))
                    {
                        s = 5;
                    }

                    else if ((true))
                    {
                        s = 19;
                    }


                    input.seek(index92_4);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 92, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA104_eotS =
            "\23\uffff";
    static final String DFA104_eofS =
            "\23\uffff";
    static final String DFA104_minS =
            "\1\7\2\uffff\2\0\16\uffff";
    static final String DFA104_maxS =
            "\1\u00aa\2\uffff\2\0\16\uffff";
    static final String DFA104_acceptS =
            "\1\uffff\1\1\3\uffff\1\2\14\uffff\1\3";
    static final String DFA104_specialS =
            "\3\uffff\1\0\1\1\16\uffff}>";
    static final String[] DFA104_transitionS = {
            "\1\1\4\uffff\1\5\10\uffff\1\5\3\uffff\1\5\1\uffff\1\5\1\uffff" +
                    "\2\5\3\uffff\1\5\3\uffff\1\5\5\uffff\1\22\12\uffff\1\3\1\uffff" +
                    "\1\3\2\uffff\1\3\4\uffff\1\3\3\uffff\1\5\1\1\1\uffff\1\3\6\uffff" +
                    "\2\3\1\uffff\2\5\5\uffff\1\3\2\uffff\1\5\2\uffff\1\5\3\uffff" +
                    "\1\5\1\uffff\1\5\76\uffff\1\4\6\5",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA104_eot = DFA.unpackEncodedString(DFA104_eotS);
    static final short[] DFA104_eof = DFA.unpackEncodedString(DFA104_eofS);
    static final char[] DFA104_min = DFA.unpackEncodedStringToUnsignedChars(DFA104_minS);
    static final char[] DFA104_max = DFA.unpackEncodedStringToUnsignedChars(DFA104_maxS);
    static final short[] DFA104_accept = DFA.unpackEncodedString(DFA104_acceptS);
    static final short[] DFA104_special = DFA.unpackEncodedString(DFA104_specialS);
    static final short[][] DFA104_transition;

    static
    {
        int numStates = DFA104_transitionS.length;
        DFA104_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA104_transition[i] = DFA.unpackEncodedString(DFA104_transitionS[i]);
        }
    }

    class DFA104 extends DFA
    {

        public DFA104(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 104;
            this.eot = DFA104_eot;
            this.eof = DFA104_eof;
            this.min = DFA104_min;
            this.max = DFA104_max;
            this.accept = DFA104_accept;
            this.special = DFA104_special;
            this.transition = DFA104_transition;
        }

        public String getDescription()
        {
            return "902:1: forInit : ( localVariableDeclaration -> ^( FOR_INIT localVariableDeclaration ) | expressionList -> ^( FOR_INIT expressionList ) | -> ^( FOR_INIT ) );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA104_3 = input.LA(1);


                    int index104_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred147_Java()))
                    {
                        s = 1;
                    }

                    else if ((synpred148_Java()))
                    {
                        s = 5;
                    }


                    input.seek(index104_3);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA104_4 = input.LA(1);


                    int index104_4 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred147_Java()))
                    {
                        s = 1;
                    }

                    else if ((synpred148_Java()))
                    {
                        s = 5;
                    }


                    input.seek(index104_4);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 104, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA128_eotS =
            "\16\uffff";
    static final String DFA128_eofS =
            "\16\uffff";
    static final String DFA128_minS =
            "\1\31\2\uffff\1\0\12\uffff";
    static final String DFA128_maxS =
            "\1\u00aa\2\uffff\1\0\12\uffff";
    static final String DFA128_acceptS =
            "\1\uffff\1\1\1\2\1\uffff\1\5\7\uffff\1\3\1\4";
    static final String DFA128_specialS =
            "\3\uffff\1\0\12\uffff}>";
    static final String[] DFA128_transitionS = {
            "\1\4\1\uffff\1\2\1\uffff\1\3\4\uffff\1\1\24\uffff\1\4\1\uffff" +
                    "\1\4\2\uffff\1\4\4\uffff\1\4\3\uffff\1\4\2\uffff\1\4\6\uffff" +
                    "\2\4\1\uffff\2\4\5\uffff\1\4\2\uffff\1\4\2\uffff\1\4\3\uffff" +
                    "\1\4\1\uffff\1\4\76\uffff\7\4",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA128_eot = DFA.unpackEncodedString(DFA128_eotS);
    static final short[] DFA128_eof = DFA.unpackEncodedString(DFA128_eofS);
    static final char[] DFA128_min = DFA.unpackEncodedStringToUnsignedChars(DFA128_minS);
    static final char[] DFA128_max = DFA.unpackEncodedStringToUnsignedChars(DFA128_maxS);
    static final short[] DFA128_accept = DFA.unpackEncodedString(DFA128_acceptS);
    static final short[] DFA128_special = DFA.unpackEncodedString(DFA128_specialS);
    static final short[][] DFA128_transition;

    static
    {
        int numStates = DFA128_transitionS.length;
        DFA128_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA128_transition[i] = DFA.unpackEncodedString(DFA128_transitionS[i]);
        }
    }

    class DFA128 extends DFA
    {

        public DFA128(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 128;
            this.eot = DFA128_eot;
            this.eof = DFA128_eof;
            this.min = DFA128_min;
            this.max = DFA128_max;
            this.accept = DFA128_accept;
            this.special = DFA128_special;
            this.transition = DFA128_transition;
        }

        public String getDescription()
        {
            return "1037:1: unaryExpressionRest : ( NOT unaryExpressionAll -> ^( NOT unaryExpressionAll ) | LOGICAL_NOT unaryExpressionAll -> ^( LOGICAL_NOT unaryExpressionAll ) | LPAREN simpleType RPAREN unaryExpressionAll -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] simpleType unaryExpressionAll ) | LPAREN objectType RPAREN unaryExpressionRest -> ^( CAST_EXPR[$LPAREN, \"CAST_EXPR\"] objectType unaryExpressionRest ) | postfixedExpression );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA128_3 = input.LA(1);


                    int index128_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred191_Java()))
                    {
                        s = 12;
                    }

                    else if ((synpred192_Java()))
                    {
                        s = 13;
                    }

                    else if ((true))
                    {
                        s = 4;
                    }


                    input.seek(index128_3);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 128, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA140_eotS =
            "\14\uffff";
    static final String DFA140_eofS =
            "\14\uffff";
    static final String DFA140_minS =
            "\1\31\6\uffff\1\17\4\uffff";
    static final String DFA140_maxS =
            "\1\u00aa\6\uffff\1\35\4\uffff";
    static final String DFA140_acceptS =
            "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\uffff\1\11\1\12\1\10\1\7";
    static final String DFA140_specialS =
            "\14\uffff}>";
    static final String[] DFA140_transitionS = {
            "\1\5\3\uffff\1\1\31\uffff\1\10\1\uffff\1\10\2\uffff\1\10\4\uffff" +
                    "\1\10\3\uffff\1\2\2\uffff\1\10\6\uffff\2\10\1\uffff\1\3\1\2" +
                    "\5\uffff\1\10\2\uffff\1\7\2\uffff\1\6\3\uffff\1\2\1\uffff\1" +
                    "\11\76\uffff\1\4\6\2",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\12\15\uffff\1\13",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA140_eot = DFA.unpackEncodedString(DFA140_eotS);
    static final short[] DFA140_eof = DFA.unpackEncodedString(DFA140_eofS);
    static final char[] DFA140_min = DFA.unpackEncodedStringToUnsignedChars(DFA140_minS);
    static final char[] DFA140_max = DFA.unpackEncodedStringToUnsignedChars(DFA140_maxS);
    static final short[] DFA140_accept = DFA.unpackEncodedString(DFA140_acceptS);
    static final short[] DFA140_special = DFA.unpackEncodedString(DFA140_specialS);
    static final short[][] DFA140_transition;

    static
    {
        int numStates = DFA140_transitionS.length;
        DFA140_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA140_transition[i] = DFA.unpackEncodedString(DFA140_transitionS[i]);
        }
    }

    class DFA140 extends DFA
    {

        public DFA140(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 140;
            this.eot = DFA140_eot;
            this.eof = DFA140_eof;
            this.min = DFA140_min;
            this.max = DFA140_max;
            this.accept = DFA140_accept;
            this.special = DFA140_special;
            this.transition = DFA140_transition;
        }

        public String getDescription()
        {
            return "1073:1: primaryExpression : ( parenthesizedExpression | literal | newExpression | qualifiedIdentExpression | genericTypeArgumentListSimplified ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) ) | ( THIS -> THIS ) ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )? | SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments ) | ( SUPER DOT IDENT ) ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) ) | ( primitiveType -> primitiveType ) ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )* DOT CLASS -> ^( DOT $primaryExpression CLASS ) | VOID DOT CLASS -> ^( DOT VOID CLASS ) );";
        }
    }

    static final String DFA144_eotS =
            "\60\uffff";
    static final String DFA144_eofS =
            "\1\4\57\uffff";
    static final String DFA144_minS =
            "\1\4\1\0\1\uffff\1\0\54\uffff";
    static final String DFA144_maxS =
            "\1\114\1\0\1\uffff\1\0\54\uffff";
    static final String DFA144_acceptS =
            "\2\uffff\1\2\1\uffff\1\4\51\uffff\1\1\1\3";
    static final String DFA144_specialS =
            "\1\uffff\1\0\1\uffff\1\1\54\uffff}>";
    static final String[] DFA144_transitionS = {
            "\3\4\1\uffff\7\4\1\3\2\uffff\4\4\1\1\1\uffff\3\4\1\uffff\1\4" +
                    "\1\2\4\4\1\uffff\22\4\27\uffff\1\4",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA144_eot = DFA.unpackEncodedString(DFA144_eotS);
    static final short[] DFA144_eof = DFA.unpackEncodedString(DFA144_eofS);
    static final char[] DFA144_min = DFA.unpackEncodedStringToUnsignedChars(DFA144_minS);
    static final char[] DFA144_max = DFA.unpackEncodedStringToUnsignedChars(DFA144_maxS);
    static final short[] DFA144_accept = DFA.unpackEncodedString(DFA144_acceptS);
    static final short[] DFA144_special = DFA.unpackEncodedString(DFA144_specialS);
    static final short[][] DFA144_transition;

    static
    {
        int numStates = DFA144_transitionS.length;
        DFA144_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA144_transition[i] = DFA.unpackEncodedString(DFA144_transitionS[i]);
        }
    }

    class DFA144 extends DFA
    {

        public DFA144(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 144;
            this.eot = DFA144_eot;
            this.eof = DFA144_eof;
            this.min = DFA144_min;
            this.max = DFA144_max;
            this.accept = DFA144_accept;
            this.special = DFA144_special;
            this.transition = DFA144_transition;
        }

        public String getDescription()
        {
            return "1109:9: ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) | outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) | Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )?";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA144_1 = input.LA(1);


                    int index144_1 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred220_Java()))
                    {
                        s = 46;
                    }

                    else if ((true))
                    {
                        s = 4;
                    }


                    input.seek(index144_1);
                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA144_3 = input.LA(1);


                    int index144_3 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred228_Java()))
                    {
                        s = 47;
                    }

                    else if ((true))
                    {
                        s = 4;
                    }


                    input.seek(index144_3);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 144, _s, input);
            error(nvae);
            throw nvae;
        }
    }

    static final String DFA151_eotS =
            "\56\uffff";
    static final String DFA151_eofS =
            "\1\2\55\uffff";
    static final String DFA151_minS =
            "\1\4\1\0\54\uffff";
    static final String DFA151_maxS =
            "\1\114\1\0\54\uffff";
    static final String DFA151_acceptS =
            "\2\uffff\1\2\52\uffff\1\1";
    static final String DFA151_specialS =
            "\1\uffff\1\0\54\uffff}>";
    static final String[] DFA151_transitionS = {
            "\3\2\1\uffff\10\2\2\uffff\4\2\1\1\1\uffff\3\2\1\uffff\1\2\1" +
                    "\uffff\4\2\1\uffff\22\2\27\uffff\1\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA151_eot = DFA.unpackEncodedString(DFA151_eotS);
    static final short[] DFA151_eof = DFA.unpackEncodedString(DFA151_eofS);
    static final char[] DFA151_min = DFA.unpackEncodedStringToUnsignedChars(DFA151_minS);
    static final char[] DFA151_max = DFA.unpackEncodedStringToUnsignedChars(DFA151_maxS);
    static final short[] DFA151_accept = DFA.unpackEncodedString(DFA151_acceptS);
    static final short[] DFA151_special = DFA.unpackEncodedString(DFA151_specialS);
    static final short[][] DFA151_transition;

    static
    {
        int numStates = DFA151_transitionS.length;
        DFA151_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++)
        {
            DFA151_transition[i] = DFA.unpackEncodedString(DFA151_transitionS[i]);
        }
    }

    class DFA151 extends DFA
    {

        public DFA151(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 151;
            this.eot = DFA151_eot;
            this.eof = DFA151_eof;
            this.min = DFA151_min;
            this.max = DFA151_max;
            this.accept = DFA151_accept;
            this.special = DFA151_special;
            this.transition = DFA151_transition;
        }

        public String getDescription()
        {
            return "()* loopback of 1148:36: ( LBRACK expression RBRACK )*";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException
        {
            TokenStream input = (TokenStream) _input;
            int _s = s;
            switch (s)
            {
                case 0:
                    int LA151_1 = input.LA(1);


                    int index151_1 = input.index();
                    input.rewind();
                    s = -1;
                    if ((synpred236_Java()))
                    {
                        s = 45;
                    }

                    else if ((true))
                    {
                        s = 2;
                    }


                    input.seek(index151_1);
                    if (s >= 0) return s;
                    break;
            }
            if (state.backtracking > 0)
            {
                state.failed = true;
                return -1;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 151, _s, input);
            error(nvae);
            throw nvae;
        }
    }


    public static final BitSet FOLLOW_compilationUnit_in_javaSource4490 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationList_in_compilationUnit4526 = new BitSet(new long[]{0x2020100000000082L, 0x000000444CF26048L});
    public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit4536 = new BitSet(new long[]{0x2020100000000082L, 0x000000444CE26048L});
    public static final BitSet FOLLOW_importDeclaration_in_compilationUnit4547 = new BitSet(new long[]{0x2020100000000082L, 0x000000444CE26048L});
    public static final BitSet FOLLOW_typeDecls_in_compilationUnit4558 = new BitSet(new long[]{0x2020100000000082L, 0x000000444CE22048L});
    public static final BitSet FOLLOW_typeDeclaration_in_typeDecls4578 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_typeDecls4588 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration4608 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_packageDeclaration4611 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_packageDeclaration4613 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPORT_in_importDeclaration4633 = new BitSet(new long[]{0x0000000000000000L, 0x0000000004000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_STATIC_in_importDeclaration4636 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_importDeclaration4639 = new BitSet(new long[]{0x0000100000010000L});
    public static final BitSet FOLLOW_DOTSTAR_in_importDeclaration4641 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_importDeclaration4644 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_typeDeclaration4664 = new BitSet(new long[]{0x2020000000000080L, 0x000000444CE22048L});
    public static final BitSet FOLLOW_classTypeDeclaration_in_typeDeclaration4679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceTypeDeclaration_in_typeDeclaration4694 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumTypeDeclaration_in_typeDeclaration4709 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_typeDeclaration4724 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CLASS_in_classTypeDeclaration4755 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_classTypeDeclaration4757 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000810L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_classTypeDeclaration4759 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000810L});
    public static final BitSet FOLLOW_classExtendsClause_in_classTypeDeclaration4762 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000810L});
    public static final BitSet FOLLOW_implementsClause_in_classTypeDeclaration4765 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000810L});
    public static final BitSet FOLLOW_classBody_in_classTypeDeclaration4768 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EXTENDS_in_classExtendsClause4817 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_classExtendsClause4819 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EXTENDS_in_interfaceExtendsClause4856 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_typeList_in_interfaceExtendsClause4858 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPLEMENTS_in_implementsClause4895 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_typeList_in_implementsClause4897 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LESS_THAN_in_genericTypeParameterList4934 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeParameter_in_genericTypeParameterList4936 = new BitSet(new long[]{0x0000800000100900L});
    public static final BitSet FOLLOW_COMMA_in_genericTypeParameterList4939 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeParameter_in_genericTypeParameterList4941 = new BitSet(new long[]{0x0000800000100900L});
    public static final BitSet FOLLOW_genericTypeListClosing_in_genericTypeParameterList4945 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GREATER_THAN_in_genericTypeListClosing5060 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SHIFT_RIGHT_in_genericTypeListClosing5070 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BIT_SHIFT_RIGHT_in_genericTypeListClosing5080 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_genericTypeParameter5108 = new BitSet(new long[]{0x0000000000000002L, 0x0000000000000010L});
    public static final BitSet FOLLOW_bound_in_genericTypeParameter5110 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EXTENDS_in_bound5148 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_bound5150 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_AND_in_bound5153 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_bound5155 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_ENUM_in_enumTypeDeclaration5196 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_enumTypeDeclaration5198 = new BitSet(new long[]{0x0000000000800000L, 0x0000000000000800L});
    public static final BitSet FOLLOW_implementsClause_in_enumTypeDeclaration5200 = new BitSet(new long[]{0x0000000000800000L, 0x0000000000000800L});
    public static final BitSet FOLLOW_enumBody_in_enumTypeDeclaration5203 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_enumBody5246 = new BitSet(new long[]{0x0020140000000880L, 0x000000444CE20040L, 0x0000001000000000L});
    public static final BitSet FOLLOW_enumScopeDeclarations_in_enumBody5248 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_RCURLY_in_enumBody5250 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumConstants_in_enumScopeDeclarations5287 = new BitSet(new long[]{0x0000100000000802L});
    public static final BitSet FOLLOW_COMMA_in_enumScopeDeclarations5291 = new BitSet(new long[]{0x0000100000000002L});
    public static final BitSet FOLLOW_enumClassScopeDeclarations_in_enumScopeDeclarations5296 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_enumClassScopeDeclarations5316 = new BitSet(new long[]{0x32A0100002800082L, 0x000000644EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_classScopeDeclarations_in_enumClassScopeDeclarations5318 = new BitSet(new long[]{0x32A0100002800082L, 0x000000644EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_enumConstant_in_enumConstants5357 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_enumConstants5360 = new BitSet(new long[]{0x0020000000000080L, 0x000000444CE20040L, 0x0000001000000000L});
    public static final BitSet FOLLOW_enumConstant_in_enumConstants5363 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_annotationList_in_enumConstant5384 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_enumConstant5386 = new BitSet(new long[]{0x0000000022800002L, 0x0000000000000810L});
    public static final BitSet FOLLOW_arguments_in_enumConstant5389 = new BitSet(new long[]{0x0000000002800002L, 0x0000000000000810L});
    public static final BitSet FOLLOW_classBody_in_enumConstant5392 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_interfaceTypeDeclaration5413 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_interfaceTypeDeclaration5415 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000010L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_interfaceTypeDeclaration5417 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000010L});
    public static final BitSet FOLLOW_interfaceExtendsClause_in_interfaceTypeDeclaration5420 = new BitSet(new long[]{0x0000000002800000L, 0x0000000000000010L});
    public static final BitSet FOLLOW_interfaceBody_in_interfaceTypeDeclaration5423 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeList5469 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_typeList5472 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_typeList5475 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_LCURLY_in_classBody5496 = new BitSet(new long[]{0x32A0140002800080L, 0x000000644EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_classScopeDeclarations_in_classBody5498 = new BitSet(new long[]{0x32A0140002800080L, 0x000000644EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_RCURLY_in_classBody5501 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_interfaceBody5539 = new BitSet(new long[]{0x32A0140002000080L, 0x000000644EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_interfaceScopeDeclarations_in_interfaceBody5541 = new BitSet(new long[]{0x32A0140002000080L, 0x000000644EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_RCURLY_in_interfaceBody5544 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_classScopeDeclarations5582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STATIC_in_classScopeDeclarations5611 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_classScopeDeclarations5613 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_classScopeDeclarations5636 = new BitSet(new long[]{0x1280000002000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_classScopeDeclarations5650 = new BitSet(new long[]{0x1280000000000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_classScopeDeclarations5669 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_classScopeDeclarations5671 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_classScopeDeclarations5673 = new BitSet(new long[]{0x0000100000C00000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_classScopeDeclarations5675 = new BitSet(new long[]{0x0000100000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_classScopeDeclarations5678 = new BitSet(new long[]{0x0000100000800000L});
    public static final BitSet FOLLOW_block_in_classScopeDeclarations5682 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_classScopeDeclarations5686 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_classScopeDeclarations5748 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_classScopeDeclarations5750 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_classScopeDeclarations5752 = new BitSet(new long[]{0x0000100000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_classScopeDeclarations5754 = new BitSet(new long[]{0x0000100000800000L});
    public static final BitSet FOLLOW_block_in_classScopeDeclarations5758 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_classScopeDeclarations5762 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_classScopeDeclarations5821 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_classScopeDeclarations5823 = new BitSet(new long[]{0x0000000000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_classScopeDeclarations5825 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_classScopeDeclarations5828 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_classScopeDeclarations5892 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_classFieldDeclaratorList_in_classScopeDeclarations5894 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_classScopeDeclarations5896 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_classScopeDeclarations5941 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_classScopeDeclarations5951 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_interfaceScopeDeclarations5971 = new BitSet(new long[]{0x1280000002000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_interfaceScopeDeclarations5985 = new BitSet(new long[]{0x1280000000000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_interfaceScopeDeclarations6004 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_interfaceScopeDeclarations6006 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_interfaceScopeDeclarations6008 = new BitSet(new long[]{0x0000100000400000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_interfaceScopeDeclarations6010 = new BitSet(new long[]{0x0000100000000000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_interfaceScopeDeclarations6013 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceScopeDeclarations6016 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_interfaceScopeDeclarations6074 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_interfaceScopeDeclarations6076 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_interfaceScopeDeclarations6078 = new BitSet(new long[]{0x0000100000000000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_interfaceScopeDeclarations6080 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceScopeDeclarations6083 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_interfaceScopeDeclarations6146 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_interfaceFieldDeclaratorList_in_interfaceScopeDeclarations6148 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceScopeDeclarations6150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_interfaceScopeDeclarations6195 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_interfaceScopeDeclarations6205 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classFieldDeclarator_in_classFieldDeclaratorList6225 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_classFieldDeclaratorList6228 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_classFieldDeclarator_in_classFieldDeclaratorList6230 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_variableDeclaratorId_in_classFieldDeclarator6269 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_ASSIGN_in_classFieldDeclarator6272 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_variableInitializer_in_classFieldDeclarator6274 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclarator_in_interfaceFieldDeclaratorList6315 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_interfaceFieldDeclaratorList6318 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_interfaceFieldDeclarator_in_interfaceFieldDeclaratorList6320 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_variableDeclaratorId_in_interfaceFieldDeclarator6359 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_ASSIGN_in_interfaceFieldDeclarator6361 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_variableInitializer_in_interfaceFieldDeclarator6363 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_variableDeclaratorId6401 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_variableDeclaratorId6404 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayInitializer_in_variableInitializer6424 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_variableInitializer6434 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_arrayDeclarator6453 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACK_in_arrayDeclarator6455 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayDeclarator_in_arrayDeclaratorList6489 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_LCURLY_in_arrayInitializer6527 = new BitSet(new long[]{0x128004446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer6530 = new BitSet(new long[]{0x0000040000000800L});
    public static final BitSet FOLLOW_COMMA_in_arrayInitializer6533 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer6535 = new BitSet(new long[]{0x0000040000000800L});
    public static final BitSet FOLLOW_COMMA_in_arrayInitializer6539 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_RCURLY_in_arrayInitializer6544 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THROWS_in_throwsClause6582 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_qualifiedIdentList_in_throwsClause6584 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifier_in_modifierList6621 = new BitSet(new long[]{0x0020000000000082L, 0x000000444CE20040L});
    public static final BitSet FOLLOW_PUBLIC_in_modifier6659 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PROTECTED_in_modifier6669 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PRIVATE_in_modifier6679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STATIC_in_modifier6689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ABSTRACT_in_modifier6699 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NATIVE_in_modifier6709 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_modifier6719 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRANSIENT_in_modifier6729 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOLATILE_in_modifier6739 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRICTFP_in_modifier6749 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localModifier_in_modifier6759 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localModifier_in_localModifierList6778 = new BitSet(new long[]{0x0020000000000082L, 0x000000444CE20040L});
    public static final BitSet FOLLOW_FINAL_in_localModifier6815 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_localModifier6825 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleType_in_type6844 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_objectType_in_type6854 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitiveType_in_simpleType6874 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_simpleType6876 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedTypeIdent_in_objectType6917 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_objectType6919 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedTypeIdentSimplified_in_objectTypeSimplified6959 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_objectTypeSimplified6961 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeIdent_in_qualifiedTypeIdent7001 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedTypeIdent7004 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_typeIdent_in_qualifiedTypeIdent7006 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_typeIdentSimplified_in_qualifiedTypeIdentSimplified7045 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedTypeIdentSimplified7048 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_typeIdentSimplified_in_qualifiedTypeIdentSimplified7050 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_IDENT_in_typeIdent7089 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_genericTypeArgumentList_in_typeIdent7092 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_typeIdentSimplified7112 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_typeIdentSimplified7115 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_primitiveType0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LESS_THAN_in_genericTypeArgumentList7224 = new BitSet(new long[]{0x1280010000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgument_in_genericTypeArgumentList7226 = new BitSet(new long[]{0x0000800000100900L});
    public static final BitSet FOLLOW_COMMA_in_genericTypeArgumentList7229 = new BitSet(new long[]{0x1280010000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgument_in_genericTypeArgumentList7231 = new BitSet(new long[]{0x0000800000100900L});
    public static final BitSet FOLLOW_genericTypeListClosing_in_genericTypeArgumentList7235 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_genericTypeArgument7273 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QUESTION_in_genericTypeArgument7283 = new BitSet(new long[]{0x0000000000000002L, 0x0000000010000010L});
    public static final BitSet FOLLOW_genericWildcardBoundType_in_genericTypeArgument7285 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_genericWildcardBoundType7323 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_genericWildcardBoundType7332 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LESS_THAN_in_genericTypeArgumentListSimplified7351 = new BitSet(new long[]{0x1280010000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgumentSimplified_in_genericTypeArgumentListSimplified7353 = new BitSet(new long[]{0x0000800000100900L});
    public static final BitSet FOLLOW_COMMA_in_genericTypeArgumentListSimplified7356 = new BitSet(new long[]{0x1280010000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgumentSimplified_in_genericTypeArgumentListSimplified7358 = new BitSet(new long[]{0x0000800000100900L});
    public static final BitSet FOLLOW_genericTypeListClosing_in_genericTypeArgumentListSimplified7362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_genericTypeArgumentSimplified7400 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QUESTION_in_genericTypeArgumentSimplified7410 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_qualifiedIdentList7429 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_qualifiedIdentList7432 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_qualifiedIdentList7435 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_LPAREN_in_formalParameterList7456 = new BitSet(new long[]{0x12A0080000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterStandardDecl_in_formalParameterList7483 = new BitSet(new long[]{0x0000080000000800L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterList7486 = new BitSet(new long[]{0x12A0000000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterStandardDecl_in_formalParameterList7488 = new BitSet(new long[]{0x0000080000000800L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterList7493 = new BitSet(new long[]{0x12A0000000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterVarArgDecl_in_formalParameterList7495 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_formalParameterVarArgDecl_in_formalParameterList7550 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_formalParameterList7625 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localModifierList_in_formalParameterStandardDecl7644 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_formalParameterStandardDecl7646 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_variableDeclaratorId_in_formalParameterStandardDecl7648 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localModifierList_in_formalParameterVarArgDecl7688 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_formalParameterVarArgDecl7690 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_ELLIPSIS_in_formalParameterVarArgDecl7692 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_variableDeclaratorId_in_formalParameterVarArgDecl7694 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_qualifiedIdentifier7738 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedIdentifier7781 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_qualifiedIdentifier7785 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_annotation_in_annotationList7834 = new BitSet(new long[]{0x0020000000000082L, 0x000000444CE20040L});
    public static final BitSet FOLLOW_AT_in_annotation7872 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_annotation7875 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_annotationInit_in_annotation7877 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_annotationInit7897 = new BitSet(new long[]{0x12A000446AA01080L, 0x0000006CDEEF8162L, 0x000007F000000000L});
    public static final BitSet FOLLOW_annotationInitializers_in_annotationInit7899 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_annotationInit7901 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationInitializer_in_annotationInitializers7938 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_annotationInitializers7941 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_annotationInitializer_in_annotationInitializers7943 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_annotationElementValue_in_annotationInitializers7973 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_annotationInitializer8010 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_ASSIGN_in_annotationInitializer8013 = new BitSet(new long[]{0x12A000446AA01080L, 0x0000006CDEEF8162L, 0x000007F000000000L});
    public static final BitSet FOLLOW_annotationElementValue_in_annotationInitializer8016 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationElementValueExpression_in_annotationElementValue8035 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_annotationElementValue8045 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationElementValueArrayInitializer_in_annotationElementValue8055 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_annotationElementValueExpression8074 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_annotationElementValueArrayInitializer8110 = new BitSet(new long[]{0x12A004446AA01880L, 0x0000006CDEEF8162L, 0x000007F000000000L});
    public static final BitSet FOLLOW_annotationElementValue_in_annotationElementValueArrayInitializer8113 = new BitSet(new long[]{0x0000040000000800L});
    public static final BitSet FOLLOW_COMMA_in_annotationElementValueArrayInitializer8116 = new BitSet(new long[]{0x12A000446AA01080L, 0x0000006CDEEF8162L, 0x000007F000000000L});
    public static final BitSet FOLLOW_annotationElementValue_in_annotationElementValueArrayInitializer8118 = new BitSet(new long[]{0x0000040000000800L});
    public static final BitSet FOLLOW_COMMA_in_annotationElementValueArrayInitializer8125 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_RCURLY_in_annotationElementValueArrayInitializer8129 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AT_in_annotationTypeDeclaration8168 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000002000L});
    public static final BitSet FOLLOW_INTERFACE_in_annotationTypeDeclaration8170 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_annotationTypeDeclaration8172 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_annotationBody_in_annotationTypeDeclaration8174 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_annotationBody8213 = new BitSet(new long[]{0x32A0040000000080L, 0x000000444EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_annotationScopeDeclarations_in_annotationBody8215 = new BitSet(new long[]{0x32A0040000000080L, 0x000000444EE3A14AL, 0x0000001000000000L});
    public static final BitSet FOLLOW_RCURLY_in_annotationBody8218 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_annotationScopeDeclarations8256 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_annotationScopeDeclarations8258 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_annotationScopeDeclarations8272 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_LPAREN_in_annotationScopeDeclarations8274 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_annotationScopeDeclarations8276 = new BitSet(new long[]{0x8000100000000000L});
    public static final BitSet FOLLOW_annotationDefaultValue_in_annotationScopeDeclarations8278 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_annotationScopeDeclarations8281 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classFieldDeclaratorList_in_annotationScopeDeclarations8323 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_annotationScopeDeclarations8325 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_annotationScopeDeclarations8370 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEFAULT_in_annotationDefaultValue8389 = new BitSet(new long[]{0x12A000446AA01080L, 0x0000006CDEEF8162L, 0x000007F000000000L});
    public static final BitSet FOLLOW_annotationElementValue_in_annotationDefaultValue8392 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_block8413 = new BitSet(new long[]{0x73E014446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_blockStatement_in_block8415 = new BitSet(new long[]{0x73E014446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_RCURLY_in_block8418 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_blockStatement8456 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_blockStatement8458 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_blockStatement8469 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_blockStatement8479 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localModifierList_in_localVariableDeclaration8498 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_localVariableDeclaration8500 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_classFieldDeclaratorList_in_localVariableDeclaration8502 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_statement8543 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_statement8553 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_statement8557 = new BitSet(new long[]{0x0000100000000400L});
    public static final BitSet FOLLOW_COLON_in_statement8571 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_statement8575 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement8577 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_statement8640 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_statement8729 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_parenthesizedExpression_in_statement8731 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement8735 = new BitSet(new long[]{0x0000000000000002L, 0x0000000000000004L});
    public static final BitSet FOLLOW_ELSE_in_statement8749 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement8753 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_statement8916 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_LPAREN_in_statement8918 = new BitSet(new long[]{0x12A010446AA01080L, 0x0000006CDEEF8162L, 0x000007F000000000L});
    public static final BitSet FOLLOW_forInit_in_statement8932 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement8934 = new BitSet(new long[]{0x128010446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_forCondition_in_statement8936 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement8938 = new BitSet(new long[]{0x128008446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_forUpdater_in_statement8940 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_statement8942 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement8944 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localModifierList_in_statement8978 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_statement8980 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_statement8982 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_COLON_in_statement8984 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_statement8986 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_statement8988 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement8990 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_statement9104 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_parenthesizedExpression_in_statement9106 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement9108 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DO_in_statement9157 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement9159 = new BitSet(new long[]{0x0000000000000000L, 0x0000008000000000L});
    public static final BitSet FOLLOW_WHILE_in_statement9161 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_parenthesizedExpression_in_statement9163 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement9165 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRY_in_statement9206 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_statement9208 = new BitSet(new long[]{0x0800000000000000L, 0x0000000000000080L});
    public static final BitSet FOLLOW_catches_in_statement9211 = new BitSet(new long[]{0x0800000000000002L, 0x0000000000000080L});
    public static final BitSet FOLLOW_finallyClause_in_statement9213 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_finallyClause_in_statement9218 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SWITCH_in_statement9261 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_parenthesizedExpression_in_statement9263 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_LCURLY_in_statement9265 = new BitSet(new long[]{0x8400000000000000L});
    public static final BitSet FOLLOW_switchBlockLabels_in_statement9267 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_RCURLY_in_statement9269 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_statement9295 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_parenthesizedExpression_in_statement9297 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_statement9299 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RETURN_in_statement9345 = new BitSet(new long[]{0x128010446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_statement9347 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement9350 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THROW_in_statement9414 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_statement9416 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement9418 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_statement9483 = new BitSet(new long[]{0x0000100000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_statement9485 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement9488 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONTINUE_in_statement9558 = new BitSet(new long[]{0x0000100000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_statement9560 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement9563 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_statement9630 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_COLON_in_statement9632 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_statement9634 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_statement9701 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement9703 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_statement9714 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catchClause_in_catches9734 = new BitSet(new long[]{0x0800000000000002L});
    public static final BitSet FOLLOW_CATCH_in_catchClause9772 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_LPAREN_in_catchClause9775 = new BitSet(new long[]{0x12A0000000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterStandardDecl_in_catchClause9778 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_catchClause9780 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_catchClause9783 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FINALLY_in_finallyClause9802 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_finallyClause9804 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchCaseLabels_in_switchBlockLabels9838 = new BitSet(new long[]{0x8400000000000000L});
    public static final BitSet FOLLOW_switchDefaultLabel_in_switchBlockLabels9840 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_switchCaseLabels_in_switchBlockLabels9845 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchCaseLabel_in_switchCaseLabels9890 = new BitSet(new long[]{0x0400000000000002L});
    public static final BitSet FOLLOW_CASE_in_switchCaseLabel9910 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_switchCaseLabel9913 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_COLON_in_switchCaseLabel9915 = new BitSet(new long[]{0x73E010446AA01082L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_blockStatement_in_switchCaseLabel9918 = new BitSet(new long[]{0x73E010446AA01082L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_DEFAULT_in_switchDefaultLabel9938 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_COLON_in_switchDefaultLabel9941 = new BitSet(new long[]{0x73E010446AA01082L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_blockStatement_in_switchDefaultLabel9944 = new BitSet(new long[]{0x73E010446AA01082L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_forInit9964 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_forInit9986 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_forCondition10070 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_forUpdater10108 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_parenthesizedExpression10148 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_parenthesizedExpression10150 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_parenthesizedExpression10152 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionList10189 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_expressionList10192 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_expressionList10195 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_assignmentExpression_in_expression10216 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_assignmentExpression10252 = new BitSet(new long[]{0x001540A280004262L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentExpression10270 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_PLUS_ASSIGN_in_assignmentExpression10289 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_MINUS_ASSIGN_in_assignmentExpression10308 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_STAR_ASSIGN_in_assignmentExpression10327 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_DIV_ASSIGN_in_assignmentExpression10346 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_AND_ASSIGN_in_assignmentExpression10365 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_OR_ASSIGN_in_assignmentExpression10384 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_XOR_ASSIGN_in_assignmentExpression10403 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_MOD_ASSIGN_in_assignmentExpression10422 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_SHIFT_LEFT_ASSIGN_in_assignmentExpression10441 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_SHIFT_RIGHT_ASSIGN_in_assignmentExpression10460 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_BIT_SHIFT_RIGHT_ASSIGN_in_assignmentExpression10479 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_assignmentExpression10500 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logicalOrExpression_in_conditionalExpression10521 = new BitSet(new long[]{0x0000010000000002L});
    public static final BitSet FOLLOW_QUESTION_in_conditionalExpression10524 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpression10527 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_COLON_in_conditionalExpression10529 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression10532 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logicalAndExpression_in_logicalOrExpression10553 = new BitSet(new long[]{0x0000000010000002L});
    public static final BitSet FOLLOW_LOGICAL_OR_in_logicalOrExpression10556 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_logicalAndExpression_in_logicalOrExpression10559 = new BitSet(new long[]{0x0000000010000002L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_logicalAndExpression10580 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_LOGICAL_AND_in_logicalAndExpression10583 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_logicalAndExpression10586 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression10607 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_OR_in_inclusiveOrExpression10610 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression10613 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression10634 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_XOR_in_exclusiveOrExpression10637 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression10640 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression10661 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_AND_in_andExpression10664 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression10667 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression10688 = new BitSet(new long[]{0x0000000800040002L});
    public static final BitSet FOLLOW_EQUAL_in_equalityExpression10706 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_NOT_EQUAL_in_equalityExpression10725 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression10754 = new BitSet(new long[]{0x0000000800040002L});
    public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression10784 = new BitSet(new long[]{0x0000000000000002L, 0x0000000000001000L});
    public static final BitSet FOLLOW_INSTANCEOF_in_instanceOfExpression10787 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_instanceOfExpression10790 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression10811 = new BitSet(new long[]{0x0000000003180002L});
    public static final BitSet FOLLOW_LESS_OR_EQUAL_in_relationalExpression10829 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_GREATER_OR_EQUAL_in_relationalExpression10848 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_LESS_THAN_in_relationalExpression10867 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_GREATER_THAN_in_relationalExpression10886 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression10915 = new BitSet(new long[]{0x0000000003180002L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression10945 = new BitSet(new long[]{0x0000A00000000102L});
    public static final BitSet FOLLOW_BIT_SHIFT_RIGHT_in_shiftExpression10963 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_SHIFT_RIGHT_in_shiftExpression10982 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_SHIFT_LEFT_in_shiftExpression11001 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression11030 = new BitSet(new long[]{0x0000A00000000102L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression11060 = new BitSet(new long[]{0x0000004040000002L});
    public static final BitSet FOLLOW_PLUS_in_additiveExpression11078 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_MINUS_in_additiveExpression11097 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression11126 = new BitSet(new long[]{0x0000004040000002L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_multiplicativeExpression11156 = new BitSet(new long[]{0x0002000100002002L});
    public static final BitSet FOLLOW_STAR_in_multiplicativeExpression11174 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_DIV_in_multiplicativeExpression11193 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_MOD_in_multiplicativeExpression11212 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_multiplicativeExpression11241 = new BitSet(new long[]{0x0002000100002002L});
    public static final BitSet FOLLOW_PLUS_in_unaryExpressionAll11271 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_unaryExpressionAll11273 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MINUS_in_unaryExpressionAll11297 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_unaryExpressionAll11299 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INC_in_unaryExpressionAll11322 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_postfixedExpression_in_unaryExpressionAll11324 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEC_in_unaryExpressionAll11348 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_postfixedExpression_in_unaryExpressionAll11350 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryExpressionRest_in_unaryExpressionAll11374 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_unaryExpressionRest11393 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_unaryExpressionRest11395 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LOGICAL_NOT_in_unaryExpressionRest11439 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_unaryExpressionRest11441 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_unaryExpressionRest11477 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L});
    public static final BitSet FOLLOW_simpleType_in_unaryExpressionRest11479 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_unaryExpressionRest11481 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_unaryExpressionRest11483 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_unaryExpressionRest11509 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_objectType_in_unaryExpressionRest11511 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_unaryExpressionRest11513 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionRest_in_unaryExpressionRest11515 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_postfixedExpression_in_unaryExpressionRest11540 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primaryExpression_in_postfixedExpression11572 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_DOT_in_postfixedExpression11634 = new BitSet(new long[]{0x0000000002000000L, 0x0000000090040000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_postfixedExpression11656 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_postfixedExpression11738 = new BitSet(new long[]{0x0000000020609002L});
    public static final BitSet FOLLOW_arguments_in_postfixedExpression11816 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_THIS_in_postfixedExpression11890 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_SUPER_in_postfixedExpression11953 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_postfixedExpression11955 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_SUPER_in_postfixedExpression12008 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_DOT_in_postfixedExpression12012 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_postfixedExpression12014 = new BitSet(new long[]{0x0000000020609002L});
    public static final BitSet FOLLOW_arguments_in_postfixedExpression12081 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_innerNewExpression_in_postfixedExpression12152 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_LBRACK_in_postfixedExpression12209 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_postfixedExpression12211 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACK_in_postfixedExpression12213 = new BitSet(new long[]{0x0000000000609002L});
    public static final BitSet FOLLOW_INC_in_postfixedExpression12274 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEC_in_postfixedExpression12298 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parenthesizedExpression_in_primaryExpression12338 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primaryExpression12348 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_newExpression_in_primaryExpression12358 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedIdentExpression_in_primaryExpression12368 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_primaryExpression12378 = new BitSet(new long[]{0x0000000000000000L, 0x0000000090000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_SUPER_in_primaryExpression12392 = new BitSet(new long[]{0x0000000020008000L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12410 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_primaryExpression12470 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_primaryExpression12472 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12474 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_primaryExpression12541 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12543 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_primaryExpression12598 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12600 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_primaryExpression12665 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12733 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_primaryExpression12798 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12800 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_primaryExpression12856 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_DOT_in_primaryExpression12858 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_primaryExpression12860 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_arguments_in_primaryExpression12884 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitiveType_in_primaryExpression13026 = new BitSet(new long[]{0x0000000000408000L});
    public static final BitSet FOLLOW_arrayDeclarator_in_primaryExpression13085 = new BitSet(new long[]{0x0000000000408000L});
    public static final BitSet FOLLOW_DOT_in_primaryExpression13144 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_CLASS_in_primaryExpression13146 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_primaryExpression13206 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_DOT_in_primaryExpression13208 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_CLASS_in_primaryExpression13210 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_qualifiedIdentExpression13286 = new BitSet(new long[]{0x0000000020408002L});
    public static final BitSet FOLLOW_arrayDeclarator_in_qualifiedIdentExpression13356 = new BitSet(new long[]{0x0000000000408000L});
    public static final BitSet FOLLOW_DOT_in_qualifiedIdentExpression13423 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_CLASS_in_qualifiedIdentExpression13425 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_qualifiedIdentExpression13495 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedIdentExpression13556 = new BitSet(new long[]{0x2000000002000000L, 0x0000000090040000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_CLASS_in_qualifiedIdentExpression13574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_qualifiedIdentExpression13637 = new BitSet(new long[]{0x0000000000000000L, 0x0000000010000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_SUPER_in_qualifiedIdentExpression13661 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_qualifiedIdentExpression13663 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_qualifiedIdentExpression13713 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_DOT_in_qualifiedIdentExpression13717 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_qualifiedIdentExpression13719 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_qualifiedIdentExpression13721 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_qualifiedIdentExpression13771 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_qualifiedIdentExpression13773 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_qualifiedIdentExpression13848 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_qualifiedIdentExpression13914 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_qualifiedIdentExpression13916 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_innerNewExpression_in_qualifiedIdentExpression13964 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_newExpression14040 = new BitSet(new long[]{0x1280000002000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_primitiveType_in_newExpression14054 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_newArrayConstruction_in_newExpression14056 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_newExpression14100 = new BitSet(new long[]{0x1280000002000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_qualifiedTypeIdentSimplified_in_newExpression14103 = new BitSet(new long[]{0x0000000020400000L});
    public static final BitSet FOLLOW_newArrayConstruction_in_newExpression14121 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_newExpression14186 = new BitSet(new long[]{0x0000000002800002L, 0x0000000000000810L});
    public static final BitSet FOLLOW_classBody_in_newExpression14188 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_innerNewExpression14283 = new BitSet(new long[]{0x0000000002000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_innerNewExpression14285 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_innerNewExpression14288 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_innerNewExpression14290 = new BitSet(new long[]{0x0000000002800002L, 0x0000000000000810L});
    public static final BitSet FOLLOW_classBody_in_innerNewExpression14292 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_newArrayConstruction14338 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_arrayInitializer_in_newArrayConstruction14340 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_newArrayConstruction14350 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_newArrayConstruction14353 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACK_in_newArrayConstruction14355 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_LBRACK_in_newArrayConstruction14359 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_newArrayConstruction14362 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACK_in_newArrayConstruction14364 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_newArrayConstruction14369 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_arguments14389 = new BitSet(new long[]{0x128008446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expressionList_in_arguments14391 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_arguments14394 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GREATER_THAN_in_synpred14_Java5060 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SHIFT_RIGHT_in_synpred15_Java5070 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BIT_SHIFT_RIGHT_in_synpred16_Java5080 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_bound_in_synpred17_Java5110 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STATIC_in_synpred33_Java5611 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_synpred33_Java5613 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_synpred43_Java5650 = new BitSet(new long[]{0x1280000000000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_synpred43_Java5669 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred43_Java5671 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred43_Java5673 = new BitSet(new long[]{0x0000100000C00000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_synpred43_Java5675 = new BitSet(new long[]{0x0000100000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred43_Java5678 = new BitSet(new long[]{0x0000100000800000L});
    public static final BitSet FOLLOW_block_in_synpred43_Java5682 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred43_Java5686 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_synpred43_Java5748 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred43_Java5750 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred43_Java5752 = new BitSet(new long[]{0x0000100000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred43_Java5754 = new BitSet(new long[]{0x0000100000800000L});
    public static final BitSet FOLLOW_block_in_synpred43_Java5758 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred43_Java5762 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_synpred43_Java5821 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred43_Java5823 = new BitSet(new long[]{0x0000000000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred43_Java5825 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_synpred43_Java5828 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_synpred44_Java5636 = new BitSet(new long[]{0x1280000002000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_synpred44_Java5650 = new BitSet(new long[]{0x1280000000000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_synpred44_Java5669 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred44_Java5671 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred44_Java5673 = new BitSet(new long[]{0x0000100000C00000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_synpred44_Java5675 = new BitSet(new long[]{0x0000100000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred44_Java5678 = new BitSet(new long[]{0x0000100000800000L});
    public static final BitSet FOLLOW_block_in_synpred44_Java5682 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred44_Java5686 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_synpred44_Java5748 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred44_Java5750 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred44_Java5752 = new BitSet(new long[]{0x0000100000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred44_Java5754 = new BitSet(new long[]{0x0000100000800000L});
    public static final BitSet FOLLOW_block_in_synpred44_Java5758 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred44_Java5762 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_synpred44_Java5821 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred44_Java5823 = new BitSet(new long[]{0x0000000000800000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred44_Java5825 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_block_in_synpred44_Java5828 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_synpred44_Java5892 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_classFieldDeclaratorList_in_synpred44_Java5894 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred44_Java5896 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_synpred45_Java5941 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_synpred51_Java5985 = new BitSet(new long[]{0x1280000000000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_synpred51_Java6004 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred51_Java6006 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred51_Java6008 = new BitSet(new long[]{0x0000100000400000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_synpred51_Java6010 = new BitSet(new long[]{0x0000100000000000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred51_Java6013 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred51_Java6016 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_synpred51_Java6074 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred51_Java6076 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred51_Java6078 = new BitSet(new long[]{0x0000100000000000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred51_Java6080 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred51_Java6083 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_synpred52_Java5971 = new BitSet(new long[]{0x1280000002000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeParameterList_in_synpred52_Java5985 = new BitSet(new long[]{0x1280000000000000L, 0x0000002002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_synpred52_Java6004 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred52_Java6006 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred52_Java6008 = new BitSet(new long[]{0x0000100000400000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_synpred52_Java6010 = new BitSet(new long[]{0x0000100000000000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred52_Java6013 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred52_Java6016 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_synpred52_Java6074 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred52_Java6076 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_formalParameterList_in_synpred52_Java6078 = new BitSet(new long[]{0x0000100000000000L, 0x0000000200000000L});
    public static final BitSet FOLLOW_throwsClause_in_synpred52_Java6080 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred52_Java6083 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_synpred52_Java6146 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_interfaceFieldDeclaratorList_in_synpred52_Java6148 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred52_Java6150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_synpred53_Java6195 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayDeclarator_in_synpred59_Java6489 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_synpred77_Java6876 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayDeclaratorList_in_synpred78_Java6919 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred80_Java7004 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_typeIdent_in_synpred80_Java7006 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMMA_in_synpred91_Java7229 = new BitSet(new long[]{0x1280010000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_genericTypeArgument_in_synpred91_Java7231 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericWildcardBoundType_in_synpred93_Java7285 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMMA_in_synpred98_Java7486 = new BitSet(new long[]{0x12A0000000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterStandardDecl_in_synpred98_Java7488 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_formalParameterStandardDecl_in_synpred100_Java7483 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_synpred100_Java7486 = new BitSet(new long[]{0x12A0000000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterStandardDecl_in_synpred100_Java7488 = new BitSet(new long[]{0x0000000000000802L});
    public static final BitSet FOLLOW_COMMA_in_synpred100_Java7493 = new BitSet(new long[]{0x12A0000000000080L, 0x000000444EE38142L, 0x0000001000000000L});
    public static final BitSet FOLLOW_formalParameterVarArgDecl_in_synpred100_Java7495 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_formalParameterVarArgDecl_in_synpred101_Java7550 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred102_Java7781 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred102_Java7785 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_synpred103_Java7834 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifierList_in_synpred115_Java8256 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_type_in_synpred115_Java8258 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred115_Java8272 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_LPAREN_in_synpred115_Java8274 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred115_Java8276 = new BitSet(new long[]{0x8000100000000000L});
    public static final BitSet FOLLOW_annotationDefaultValue_in_synpred115_Java8278 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred115_Java8281 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classFieldDeclaratorList_in_synpred115_Java8323 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred115_Java8325 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_synpred117_Java8456 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred117_Java8458 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDeclaration_in_synpred118_Java8469 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_synpred122_Java8749 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_synpred122_Java8753 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forInit_in_synpred124_Java8932 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred124_Java8934 = new BitSet(new long[]{0x128010446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_forCondition_in_synpred124_Java8936 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred124_Java8938 = new BitSet(new long[]{0x128008446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_forUpdater_in_synpred124_Java8940 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred124_Java8942 = new BitSet(new long[]{0x73E010446AA01080L, 0x000000FDFFEFA76BL, 0x000007F000000000L});
    public static final BitSet FOLLOW_statement_in_synpred124_Java8944 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchCaseLabel_in_synpred144_Java9890 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_synpred147_Java9964 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_synpred148_Java9986 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_synpred191_Java11477 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L});
    public static final BitSet FOLLOW_simpleType_in_synpred191_Java11479 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred191_Java11481 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionAll_in_synpred191_Java11483 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_synpred192_Java11509 = new BitSet(new long[]{0x1280000000000000L, 0x0000000002018102L, 0x0000001000000000L});
    public static final BitSet FOLLOW_objectType_in_synpred192_Java11511 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred192_Java11513 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_unaryExpressionRest_in_synpred192_Java11515 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayDeclarator_in_synpred220_Java13356 = new BitSet(new long[]{0x0000000000408000L});
    public static final BitSet FOLLOW_DOT_in_synpred220_Java13423 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_CLASS_in_synpred220_Java13425 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred228_Java13556 = new BitSet(new long[]{0x2000000002000000L, 0x0000000090040000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_CLASS_in_synpred228_Java13574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_genericTypeArgumentListSimplified_in_synpred228_Java13637 = new BitSet(new long[]{0x0000000000000000L, 0x0000000010000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_SUPER_in_synpred228_Java13661 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_synpred228_Java13663 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_synpred228_Java13713 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_DOT_in_synpred228_Java13717 = new BitSet(new long[]{0x0000000000000000L, 0x0000000000000000L, 0x0000001000000000L});
    public static final BitSet FOLLOW_IDENT_in_synpred228_Java13719 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_synpred228_Java13721 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_synpred228_Java13771 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_synpred228_Java13773 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_synpred228_Java13848 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_synpred228_Java13914 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_arguments_in_synpred228_Java13916 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_innerNewExpression_in_synpred228_Java13964 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_synpred236_Java14359 = new BitSet(new long[]{0x128000446AA01000L, 0x00000028920D8122L, 0x000007F000000000L});
    public static final BitSet FOLLOW_expression_in_synpred236_Java14362 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACK_in_synpred236_Java14364 = new BitSet(new long[]{0x0000000000000002L});

}